make more use of the denom cache

packages/taler-wallet-cli/src/harness/harness.ts

@@ -1979,6 +1979,7 @@ export async function runTestWithState(
       });
       await new Promise<void>((resolve, reject) => {
         rl.question("Press enter to shut down test.", () => {
+          console.error("Requested shutdown");
           resolve();
         });
       });

packages/taler-wallet-core/src/common.ts

@@ -228,7 +228,7 @@ export interface InternalWalletState {
 
   getDenomInfo(
     ws: InternalWalletState,
-    tx: GetReadWriteAccess<{
+    tx: GetReadOnlyAccess<{
       denominations: typeof WalletStoresV1.denominations;
     }>,
     exchangeBaseUrl: string,

packages/taler-wallet-core/src/operations/deposits.ts

@@ -26,7 +26,6 @@ import {
   ContractTerms,
   CreateDepositGroupRequest,
   CreateDepositGroupResponse,
-  decodeCrock,
   DenomKeyType,
   durationFromSpec,
   GetFeeForDepositRequest,
@@ -250,6 +249,7 @@ async function processDepositGroupImpl(
       };
     }
     const url = new URL(`coins/${perm.coin_pub}/deposit`, perm.exchange_url);
+    logger.info(`depositing to ${url}`);
     const httpResp = await ws.http.postJson(url.href, requestBody);
     await readSuccessResponseJsonOrThrow(httpResp, codecForDepositSuccess());
     await ws.db
@@ -616,10 +616,12 @@ export async function getEffectiveDepositAmount(
         if (!coin) {
           throw Error("can't calculate deposit amount, coin not found");
         }
-        const denom = await tx.denominations.get([
+        const denom = await ws.getDenomInfo(
+          ws,
+          tx,
           coin.exchangeBaseUrl,
           coin.denomPubHash,
-        ]);
+        );
         if (!denom) {
           throw Error("can't find denomination to calculate deposit amount");
         }
@@ -688,10 +690,12 @@ export async function getTotalFeeForDepositAmount(
         if (!coin) {
           throw Error("can't calculate deposit amount, coin not found");
         }
-        const denom = await tx.denominations.get([
+        const denom = await ws.getDenomInfo(
+          ws,
+          tx,
           coin.exchangeBaseUrl,
           coin.denomPubHash,
-        ]);
+        );
         if (!denom) {
           throw Error("can't find denomination to calculate deposit amount");
         }

packages/taler-wallet-core/src/operations/exchanges.ts

@@ -131,7 +131,7 @@ async function handleExchangeUpdateError(
       exchange.retryInfo.retryCounter++;
       updateRetryInfoTimeout(exchange.retryInfo);
       exchange.lastError = err;
-      await tx.exchanges.put(exchange)
+      await tx.exchanges.put(exchange);
     });
   if (err) {
     ws.notify({ type: NotificationType.ExchangeOperationError, error: err });
@@ -527,11 +527,11 @@ async function updateExchangeFromUrlImpl(
     tosFound !== undefined
       ? tosFound
       : await downloadExchangeWithTermsOfService(
-        baseUrl,
+          baseUrl,
-        ws.http,
+          ws.http,
-        timeout,
+          timeout,
-        "text/plain",
+          "text/plain",
-      );
+        );
 
   let recoupGroupId: string | undefined = undefined;
 
@@ -589,7 +589,7 @@ async function updateExchangeFromUrlImpl(
       await tx.exchanges.put(r);
       await tx.exchangeDetails.put(details);
 
-      logger.trace("updating denominations in database");
+      logger.info("updating denominations in database");
       const currentDenomSet = new Set<string>(
         keysInfo.currentDenominations.map((x) => x.denomPubHash),
       );
@@ -750,9 +750,10 @@ export async function getExchangeTrust(
       if (!exchangeDetails) {
         throw Error(`exchange ${exchangeInfo.baseUrl} details not available`);
       }
-      const exchangeTrustRecord = await tx.exchangesTrustStore.indexes.byExchangeMasterPub.get(
+      const exchangeTrustRecord =
-        exchangeDetails.masterPublicKey,
+        await tx.exchangesTrustStore.indexes.byExchangeMasterPub.get(
-      );
+          exchangeDetails.masterPublicKey,
+        );
       if (
         exchangeTrustRecord &&
         exchangeTrustRecord.uids.length > 0 &&
@@ -762,9 +763,8 @@ export async function getExchangeTrust(
       }
 
       for (const auditor of exchangeDetails.auditors) {
-        const auditorTrustRecord = await tx.auditorTrust.indexes.byAuditorPub.get(
+        const auditorTrustRecord =
-          auditor.auditor_pub,
+          await tx.auditorTrust.indexes.byAuditorPub.get(auditor.auditor_pub);
-        );
         if (auditorTrustRecord && auditorTrustRecord.uids.length > 0) {
           isAudited = true;
           break;

packages/taler-wallet-core/src/operations/pay.ts

@@ -166,8 +166,10 @@ export async function getTotalPaymentCost(
           .filter((x) =>
             Amounts.isSameCurrency(x.value, pcs.coinContributions[i]),
           );
-        const amountLeft = Amounts.sub(denom.value, pcs.coinContributions[i])
+        const amountLeft = Amounts.sub(
-          .amount;
+          denom.value,
+          pcs.coinContributions[i],
+        ).amount;
         const refreshCost = getTotalRefreshCost(allDenoms, denom, amountLeft);
         costs.push(pcs.coinContributions[i]);
         costs.push(refreshCost);
@@ -290,10 +292,12 @@ export async function getCandidatePayCoins(
 
         // Denomination of the first coin, we assume that all other
         // coins have the same currency
-        const firstDenom = await tx.denominations.get([
+        const firstDenom = await ws.getDenomInfo(
+          ws,
+          tx,
           exchange.baseUrl,
           coins[0].denomPubHash,
-        ]);
+        );
         if (!firstDenom) {
           throw Error("db inconsistent");
         }
@@ -365,6 +369,7 @@ export async function applyCoinSpend(
   coinSelection: PayCoinSelection,
   allocationId: string,
 ) {
+  logger.info(`applying coin spend ${j2s(coinSelection)}`);
   for (let i = 0; i < coinSelection.coinPubs.length; i++) {
     const coin = await tx.coins.get(coinSelection.coinPubs[i]);
     if (!coin) {
@@ -525,7 +530,8 @@ async function incrementPurchasePayRetry(
       pr.payRetryInfo.retryCounter++;
       updateRetryInfoTimeout(pr.payRetryInfo);
       logger.trace(
-        `retrying pay in ${getDurationRemaining(pr.payRetryInfo.nextRetry).d_ms
+        `retrying pay in ${
+          getDurationRemaining(pr.payRetryInfo.nextRetry).d_ms
         } ms`,
       );
       pr.lastPayError = err;
@@ -812,9 +818,8 @@ async function processDownloadProposalImpl(
         (fulfillmentUrl.startsWith("http://") ||
           fulfillmentUrl.startsWith("https://"))
       ) {
-        const differentPurchase = await tx.purchases.indexes.byFulfillmentUrl.get(
+        const differentPurchase =
-          fulfillmentUrl,
+          await tx.purchases.indexes.byFulfillmentUrl.get(fulfillmentUrl);
-        );
         if (differentPurchase) {
           logger.warn("repurchase detected");
           p.proposalStatus = ProposalStatus.REPURCHASE;

packages/taler-wallet-core/src/operations/refresh.ts

@@ -67,7 +67,11 @@ import {
 } from "@gnu-taler/taler-util";
 import { guardOperationException } from "../errors.js";
 import { updateExchangeFromUrl } from "./exchanges.js";
-import { EXCHANGE_COINS_LOCK, InternalWalletState } from "../common.js";
+import {
+  DenomInfo,
+  EXCHANGE_COINS_LOCK,
+  InternalWalletState,
+} from "../common.js";
 import {
   isWithdrawableDenom,
   selectWithdrawalDenominations,
@@ -90,7 +94,7 @@ const logger = new Logger("refresh.ts");
  */
 export function getTotalRefreshCost(
   denoms: DenominationRecord[],
-  refreshedDenom: DenominationRecord,
+  refreshedDenom: DenomInfo,
   amountLeft: AmountJson,
 ): AmountJson {
   const withdrawAmount = Amounts.sub(
@@ -193,10 +197,12 @@ async function refreshCreateSession(
       denominations: x.denominations,
     }))
     .runReadOnly(async (tx) => {
-      const oldDenom = await tx.denominations.get([
+      const oldDenom = await ws.getDenomInfo(
+        ws,
+        tx,
         exchange.baseUrl,
         coin.denomPubHash,
-      ]);
+      );
 
       if (!oldDenom) {
         throw Error("db inconsistent: denomination for coin not found");
@@ -321,10 +327,12 @@ async function refreshMelt(
 
       const oldCoin = await tx.coins.get(refreshGroup.oldCoinPubs[coinIndex]);
       checkDbInvariant(!!oldCoin, "melt coin doesn't exist");
-      const oldDenom = await tx.denominations.get([
+      const oldDenom = await ws.getDenomInfo(
+        ws,
+        tx,
         oldCoin.exchangeBaseUrl,
         oldCoin.denomPubHash,
-      ]);
+      );
       checkDbInvariant(
         !!oldDenom,
         "denomination for melted coin doesn't exist",
@@ -333,10 +341,12 @@ async function refreshMelt(
       const newCoinDenoms: RefreshNewDenomInfo[] = [];
 
       for (const dh of refreshSession.newDenoms) {
-        const newDenom = await tx.denominations.get([
+        const newDenom = await ws.getDenomInfo(
+          ws,
+          tx,
           oldCoin.exchangeBaseUrl,
           dh.denomPubHash,
-        ]);
+        );
         checkDbInvariant(
           !!newDenom,
           "new denomination for refresh not in database",
@@ -480,6 +490,7 @@ async function refreshReveal(
   refreshGroupId: string,
   coinIndex: number,
 ): Promise<void> {
+  logger.info("doing refresh reveal");
   const d = await ws.db
     .mktx((x) => ({
       refreshGroups: x.refreshGroups,
@@ -502,10 +513,12 @@ async function refreshReveal(
 
       const oldCoin = await tx.coins.get(refreshGroup.oldCoinPubs[coinIndex]);
       checkDbInvariant(!!oldCoin, "melt coin doesn't exist");
-      const oldDenom = await tx.denominations.get([
+      const oldDenom = await ws.getDenomInfo(
+        ws,
+        tx,
         oldCoin.exchangeBaseUrl,
         oldCoin.denomPubHash,
-      ]);
+      );
       checkDbInvariant(
         !!oldDenom,
         "denomination for melted coin doesn't exist",
@@ -514,10 +527,12 @@ async function refreshReveal(
       const newCoinDenoms: RefreshNewDenomInfo[] = [];
 
       for (const dh of refreshSession.newDenoms) {
-        const newDenom = await tx.denominations.get([
+        const newDenom = await ws.getDenomInfo(
+          ws,
+          tx,
           oldCoin.exchangeBaseUrl,
           dh.denomPubHash,
-        ]);
+        );
         checkDbInvariant(
           !!newDenom,
           "new denomination for refresh not in database",
@@ -794,6 +809,7 @@ async function processRefreshGroupImpl(
   refreshGroupId: string,
   forceNow: boolean,
 ): Promise<void> {
+  logger.info(`processing refresh group ${refreshGroupId}`);
   if (forceNow) {
     await resetRefreshGroupRetry(ws, refreshGroupId);
   }
@@ -823,7 +839,7 @@ async function processRefreshSession(
   refreshGroupId: string,
   coinIndex: number,
 ): Promise<void> {
-  logger.trace(
+  logger.info(
     `processing refresh session for coin ${coinIndex} of group ${refreshGroupId}`,
   );
   let refreshGroup = await ws.db
@@ -911,10 +927,12 @@ export async function createRefreshGroup(
   for (const ocp of oldCoinPubs) {
     const coin = await tx.coins.get(ocp.coinPub);
     checkDbInvariant(!!coin, "coin must be in database");
-    const denom = await tx.denominations.get([
+    const denom = await ws.getDenomInfo(
+      ws,
+      tx,
       coin.exchangeBaseUrl,
       coin.denomPubHash,
-    ]);
+    );
     checkDbInvariant(
       !!denom,
       "denomination for existing coin must be in database",
@@ -949,11 +967,12 @@ export async function createRefreshGroup(
   if (oldCoinPubs.length == 0) {
     logger.warn("created refresh group with zero coins");
     refreshGroup.timestampFinished = getTimestampNow();
+    refreshGroup.operationStatus = OperationStatus.Finished;
   }
 
   await tx.refreshGroups.put(refreshGroup);
 
-  logger.trace(`created refresh group ${refreshGroupId}`);
+  logger.info(`created refresh group ${refreshGroupId}`);
 
   processRefreshGroup(ws, refreshGroupId).catch((e) => {
     logger.warn(`processing refresh group ${refreshGroupId} failed: ${e}`);

packages/taler-wallet-core/src/operations/withdraw.ts

@@ -453,6 +453,9 @@ async function processPlanchetExchangeRequest(
   withdrawalGroup: WithdrawalGroupRecord,
   coinIdx: number,
 ): Promise<WithdrawResponse | undefined> {
+  logger.info(
+    `processing planchet exchange request ${withdrawalGroup.withdrawalGroupId}/${coinIdx}`,
+  );
   const d = await ws.db
     .mktx((x) => ({
       withdrawalGroups: x.withdrawalGroups,
@@ -478,10 +481,12 @@ async function processPlanchetExchangeRequest(
         return;
       }
 
-      const denom = await tx.denominations.get([
+      const denom = await ws.getDenomInfo(
+        ws,
+        tx,
         withdrawalGroup.exchangeBaseUrl,
         planchet.denomPubHash,
-      ]);
+      );
 
       if (!denom) {
         logger.error("db inconsistent: denom for planchet not found");

packages/taler-wallet-core/src/util/query.ts

@@ -333,7 +333,7 @@ export interface StoreReadWriteAccessor<RecordType, IndexMap> {
 
 export interface StoreWithIndexes<
   SD extends StoreDescriptor<unknown>,
-  IndexMap
+  IndexMap,
 > {
   store: SD;
   indexMap: IndexMap;
@@ -586,7 +586,7 @@ export class DbAccess<StoreMap> {
 
   mktx<
     PickerType extends (x: StoreMap) => unknown,
-    BoundStores extends GetPickerType<PickerType, StoreMap>
+    BoundStores extends GetPickerType<PickerType, StoreMap>,
   >(f: PickerType): TransactionContext<BoundStores> {
     const storePick = f(this.stores) as any;
     if (typeof storePick !== "object" || storePick === null) {

packages/taler-wallet-core/src/wallet.ts

@@ -626,6 +626,7 @@ async function setCoinSuspended(
  */
 async function dumpCoins(ws: InternalWalletState): Promise<CoinDumpJson> {
   const coinsJson: CoinDumpJson = { coins: [] };
+  logger.info("dumping coins");
   await ws.db
     .mktx((x) => ({
       coins: x.coins,
@@ -1206,9 +1207,15 @@ class InternalWalletStateImpl implements InternalWalletState {
     const key = `${exchangeBaseUrl}:${denomPubHash}`;
     const cached = this.denomCache[key];
     if (cached) {
+      logger.info("using cached denom");
       return cached;
     }
-    return await tx.denominations.get([exchangeBaseUrl, denomPubHash]);
+    logger.info("looking up denom denom");
+    const d = await tx.denominations.get([exchangeBaseUrl, denomPubHash]);
+    if (d) {
+      this.denomCache[key] = d;
+    }
+    return d;
   }
 
   notify(n: WalletNotification): void {