1 files changed, 42 insertions, 42 deletions

diff --git a/packages/taler-wallet-core/src/operations/transactions.ts b/packages/taler-wallet-core/src/operations/transactions.ts
index 868f00de7..a16809b36 100644
--- a/packages/taler-wallet-core/src/operations/transactions.ts
+++ b/packages/taler-wallet-core/src/operations/transactions.ts
@@ -58,7 +58,7 @@ import {
   RefreshGroupRecord,
   RefreshOperationStatus,
   RefundGroupRecord,
-  TipRecord,
+  RewardRecord,
   WalletContractData,
   WithdrawalGroupRecord,
   WithdrawalGroupStatus,
@@ -107,11 +107,11 @@ import {
 import {
   abortTipTransaction,
   failTipTransaction,
-  computeTipTransactionStatus,
+  computeRewardTransactionStatus,
   resumeTipTransaction,
-  suspendTipTransaction,
+  suspendRewardTransaction,
   computeTipTransactionActions,
-} from "./tip.js";
+} from "./reward.js";
 import {
   abortWithdrawalTransaction,
   augmentPaytoUrisForWithdrawal,
@@ -187,7 +187,7 @@ function shouldSkipSearch(
  */
 const txOrder: { [t in TransactionType]: number } = {
   [TransactionType.Withdrawal]: 1,
-  [TransactionType.Tip]: 2,
+  [TransactionType.Reward]: 2,
   [TransactionType.Payment]: 3,
   [TransactionType.PeerPullCredit]: 4,
   [TransactionType.PeerPullDebit]: 5,
@@ -284,12 +284,12 @@ export async function getTransactionById(
       throw Error(`no tx for refresh`);
     }
 
-    case TransactionType.Tip: {
-      const tipId = parsedTx.walletTipId;
+    case TransactionType.Reward: {
+      const tipId = parsedTx.walletRewardId;
       return await ws.db
-        .mktx((x) => [x.tips, x.operationRetries])
+        .mktx((x) => [x.rewards, x.operationRetries])
         .runReadWrite(async (tx) => {
-          const tipRecord = await tx.tips.get(tipId);
+          const tipRecord = await tx.rewards.get(tipId);
           if (!tipRecord) throw Error("not found");
 
           const retries = await tx.operationRetries.get(
@@ -818,21 +818,21 @@ function buildTransactionForDeposit(
 }
 
 function buildTransactionForTip(
-  tipRecord: TipRecord,
+  tipRecord: RewardRecord,
   ort?: OperationRetryRecord,
 ): Transaction {
   checkLogicInvariant(!!tipRecord.acceptedTimestamp);
 
   return {
-    type: TransactionType.Tip,
-    txState: computeTipTransactionStatus(tipRecord),
+    type: TransactionType.Reward,
+    txState: computeRewardTransactionStatus(tipRecord),
     txActions: computeTipTransactionActions(tipRecord),
-    amountEffective: Amounts.stringify(tipRecord.tipAmountEffective),
-    amountRaw: Amounts.stringify(tipRecord.tipAmountRaw),
+    amountEffective: Amounts.stringify(tipRecord.rewardAmountEffective),
+    amountRaw: Amounts.stringify(tipRecord.rewardAmountRaw),
     timestamp: tipRecord.acceptedTimestamp,
     transactionId: constructTransactionIdentifier({
-      tag: TransactionType.Tip,
-      walletTipId: tipRecord.walletTipId,
+      tag: TransactionType.Reward,
+      walletRewardId: tipRecord.walletRewardId,
     }),
     merchantBaseUrl: tipRecord.merchantBaseUrl,
     ...(ort?.lastError ? { error: ort.lastError } : {}),
@@ -945,7 +945,7 @@ export async function getTransactions(
       x.purchases,
       x.contractTerms,
       x.recoupGroups,
-      x.tips,
+      x.rewards,
       x.tombstones,
       x.withdrawalGroups,
       x.refreshGroups,
@@ -1200,11 +1200,11 @@ export async function getTransactions(
         );
       });
 
-      tx.tips.iter().forEachAsync(async (tipRecord) => {
+      tx.rewards.iter().forEachAsync(async (tipRecord) => {
         if (
           shouldSkipCurrency(
             transactionsRequest,
-            Amounts.parseOrThrow(tipRecord.tipAmountRaw).currency,
+            Amounts.parseOrThrow(tipRecord.rewardAmountRaw).currency,
           )
         ) {
           return;
@@ -1267,7 +1267,7 @@ export type ParsedTransactionIdentifier =
   | { tag: TransactionType.PeerPushDebit; pursePub: string }
   | { tag: TransactionType.Refresh; refreshGroupId: string }
   | { tag: TransactionType.Refund; refundGroupId: string }
-  | { tag: TransactionType.Tip; walletTipId: string }
+  | { tag: TransactionType.Reward; walletRewardId: string }
   | { tag: TransactionType.Withdrawal; withdrawalGroupId: string }
   | { tag: TransactionType.InternalWithdrawal; withdrawalGroupId: string };
 
@@ -1291,8 +1291,8 @@ export function constructTransactionIdentifier(
       return `txn:${pTxId.tag}:${pTxId.refreshGroupId}` as TransactionIdStr;
     case TransactionType.Refund:
       return `txn:${pTxId.tag}:${pTxId.refundGroupId}` as TransactionIdStr;
-    case TransactionType.Tip:
-      return `txn:${pTxId.tag}:${pTxId.walletTipId}` as TransactionIdStr;
+    case TransactionType.Reward:
+      return `txn:${pTxId.tag}:${pTxId.walletRewardId}` as TransactionIdStr;
     case TransactionType.Withdrawal:
       return `txn:${pTxId.tag}:${pTxId.withdrawalGroupId}` as TransactionIdStr;
     case TransactionType.InternalWithdrawal:
@@ -1346,10 +1346,10 @@ export function parseTransactionIdentifier(
         tag: TransactionType.Refund,
         refundGroupId: rest[0],
       };
-    case TransactionType.Tip:
+    case TransactionType.Reward:
       return {
-        tag: TransactionType.Tip,
-        walletTipId: rest[0],
+        tag: TransactionType.Reward,
+        walletRewardId: rest[0],
       };
     case TransactionType.Withdrawal:
       return {
@@ -1427,10 +1427,10 @@ export async function retryTransaction(
       stopLongpolling(ws, taskId);
       break;
     }
-    case TransactionType.Tip: {
+    case TransactionType.Reward: {
       const taskId = constructTaskIdentifier({
-        tag: PendingTaskType.TipPickup,
-        walletTipId: parsedTx.walletTipId,
+        tag: PendingTaskType.RewardPickup,
+        walletRewardId: parsedTx.walletRewardId,
       });
       await resetPendingTaskTimeout(ws, taskId);
       stopLongpolling(ws, taskId);
@@ -1522,8 +1522,8 @@ export async function suspendTransaction(
       break;
     case TransactionType.Refund:
       throw Error("refund transactions can't be suspended or resumed");
-    case TransactionType.Tip:
-      await suspendTipTransaction(ws, tx.walletTipId);
+    case TransactionType.Reward:
+      await suspendRewardTransaction(ws, tx.walletRewardId);
       break;
     default:
       assertUnreachable(tx);
@@ -1551,8 +1551,8 @@ export async function failTransaction(
       return;
     case TransactionType.Refund:
       throw Error("can't do cancel-aborting on refund transaction");
-    case TransactionType.Tip:
-      await failTipTransaction(ws, tx.walletTipId);
+    case TransactionType.Reward:
+      await failTipTransaction(ws, tx.walletRewardId);
       return;
     case TransactionType.Refresh:
       await failRefreshGroup(ws, tx.refreshGroupId);
@@ -1613,8 +1613,8 @@ export async function resumeTransaction(
       break;
     case TransactionType.Refund:
       throw Error("refund transactions can't be suspended or resumed");
-    case TransactionType.Tip:
-      await resumeTipTransaction(ws, tx.walletTipId);
+    case TransactionType.Reward:
+      await resumeTipTransaction(ws, tx.walletRewardId);
       break;
   }
 }
@@ -1763,16 +1763,16 @@ export async function deleteTransaction(
       return;
     }
 
-    case TransactionType.Tip: {
-      const tipId = parsedTx.walletTipId;
+    case TransactionType.Reward: {
+      const tipId = parsedTx.walletRewardId;
       await ws.db
-        .mktx((x) => [x.tips, x.tombstones])
+        .mktx((x) => [x.rewards, x.tombstones])
         .runReadWrite(async (tx) => {
-          const tipRecord = await tx.tips.get(tipId);
+          const tipRecord = await tx.rewards.get(tipId);
           if (tipRecord) {
-            await tx.tips.delete(tipId);
+            await tx.rewards.delete(tipId);
             await tx.tombstones.put({
-              id: TombstoneTag.DeleteTip + ":" + tipId,
+              id: TombstoneTag.DeleteReward + ":" + tipId,
             });
           }
         });
@@ -1856,8 +1856,8 @@ export async function abortTransaction(
     case TransactionType.Deposit:
       await abortDepositGroup(ws, txId.depositGroupId);
       break;
-    case TransactionType.Tip:
-      await abortTipTransaction(ws, txId.walletTipId);
+    case TransactionType.Reward:
+      await abortTipTransaction(ws, txId.walletRewardId);
       break;
     case TransactionType.Refund:
       throw Error("can't abort refund transactions");