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

/*
 This file is part of GNU Taler
 (C) 2015-2019 GNUnet e.V.

 GNU Taler is free software; you can redistribute it and/or modify it under the
 terms of the GNU General Public License as published by the Free Software
 Foundation; either version 3, or (at your option) any later version.

 GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

 You should have received a copy of the GNU General Public License along with
 GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */

/**
 * High-level wallet operations that should be indepentent from the underlying
 * browser extension interface.
 */

/**
 * Imports.
 */
import {
  BackupRecovery,
  codecForAny,
  codecForDeleteTransactionRequest,
  codecForRetryTransactionRequest,
  DeleteTransactionRequest,
  durationFromSpec,
  durationMax,
  durationMin,
  getDurationRemaining,
  isTimestampExpired,
  j2s,
  TalerErrorCode,
  Timestamp,
  timestampMin,
  WalletCurrencyInfo,
} from "@gnu-taler/taler-util";
import { CryptoWorkerFactory } from "./crypto/workers/cryptoApi";
import {
  addBackupProvider,
  AddBackupProviderRequest,
  BackupInfo,
  codecForAddBackupProviderRequest,
  exportBackupEncrypted,
  getBackupInfo,
  getBackupRecovery,
  importBackupEncrypted,
  importBackupPlain,
  loadBackupRecovery,
  runBackupCycle,
} from "./operations/backup";
import { exportBackup } from "./operations/backup/export";
import { getBalances } from "./operations/balance";
import {
  createDepositGroup,
  processDepositGroup,
  trackDepositGroup,
} from "./operations/deposits";
import {
  makeErrorDetails,
  OperationFailedAndReportedError,
  OperationFailedError,
} from "./operations/errors";
import {
  acceptExchangeTermsOfService,
  getExchangeDetails,
  getExchangePaytoUri,
  updateExchangeFromUrl,
} from "./operations/exchanges";
import {
  confirmPay,
  preparePayForUri,
  processDownloadProposal,
  processPurchasePay,
  refuseProposal,
} from "./operations/pay";
import { getPendingOperations } from "./operations/pending";
import { processRecoupGroup } from "./operations/recoup";
import {
  autoRefresh,
  createRefreshGroup,
  processRefreshGroup,
} from "./operations/refresh";
import {
  abortFailedPayWithRefund,
  applyRefund,
  processPurchaseQueryRefund,
} from "./operations/refund";
import {
  createReserve,
  createTalerWithdrawReserve,
  forceQueryReserve,
  getFundingPaytoUris,
  processReserve,
} from "./operations/reserves";
import { InternalWalletState } from "./operations/state";
import {
  runIntegrationTest,
  testPay,
  withdrawTestBalance,
} from "./operations/testing";
import { acceptTip, prepareTip, processTip } from "./operations/tip";
import { deleteTransaction, getTransactions, retryTransaction } from "./operations/transactions";
import {
  getExchangeWithdrawalInfo,
  getWithdrawalDetailsForUri,
  processWithdrawGroup,
} from "./operations/withdraw";
import {
  AuditorTrustRecord,
  CoinRecord,
  CoinSourceType,
  ExchangeDetailsRecord,
  ExchangeRecord,
  ReserveRecord,
  ReserveRecordStatus,
  WalletStoresV1,
} from "./db.js";
import { NotificationType, WalletNotification } from "@gnu-taler/taler-util";
import {
  PendingOperationInfo,
  PendingOperationsResponse,
  PendingOperationType,
} from "./pending-types.js";
import { CoinDumpJson } from "@gnu-taler/taler-util";
import {
  codecForTransactionsRequest,
  TransactionsRequest,
  TransactionsResponse,
} from "@gnu-taler/taler-util";
import {
  AcceptManualWithdrawalResult,
  AcceptWithdrawalResponse,
  ApplyRefundResponse,
  BalancesResponse,
  BenchmarkResult,
  codecForAbortPayWithRefundRequest,
  codecForAcceptBankIntegratedWithdrawalRequest,
  codecForAcceptExchangeTosRequest,
  codecForAcceptManualWithdrawalRequet,
  codecForAcceptTipRequest,
  codecForAddExchangeRequest,
  codecForApplyRefundRequest,
  codecForConfirmPayRequest,
  codecForCreateDepositGroupRequest,
  codecForForceExchangeUpdateRequest,
  codecForForceRefreshRequest,
  codecForGetExchangeTosRequest,
  codecForGetWithdrawalDetailsForAmountRequest,
  codecForGetWithdrawalDetailsForUri,
  codecForIntegrationTestArgs,
  codecForPreparePayRequest,
  codecForPrepareTipRequest,
  codecForSetCoinSuspendedRequest,
  codecForTestPayArgs,
  codecForTrackDepositGroupRequest,
  codecForWithdrawTestBalance,
  ConfirmPayResult,
  CoreApiResponse,
  CreateDepositGroupRequest,
  CreateDepositGroupResponse,
  ExchangeListItem,
  ExchangesListRespose,
  GetExchangeTosResult,
  IntegrationTestArgs,
  ManualWithdrawalDetails,
  PreparePayResult,
  PrepareTipResult,
  RecoveryLoadRequest,
  RefreshReason,
  ReturnCoinsRequest,
  TestPayArgs,
  TrackDepositGroupRequest,
  TrackDepositGroupResponse,
  WithdrawTestBalanceRequest,
  WithdrawUriInfoResponse,
} from "@gnu-taler/taler-util";
import { AmountJson, Amounts } from "@gnu-taler/taler-util";
import { assertUnreachable } from "./util/assertUnreachable";
import { AsyncOpMemoSingle } from "./util/asyncMemo";
import { HttpRequestLibrary } from "./util/http";
import { Logger } from "@gnu-taler/taler-util";
import { AsyncCondition } from "./util/promiseUtils";
import { TimerGroup } from "./util/timer";
import { getExchangeTrust } from "./operations/currencies.js";
import { DbAccess } from "./util/query.js";
import { setWalletDeviceId } from "./operations/backup/state.js";

const builtinAuditors: AuditorTrustRecord[] = [
  {
    currency: "KUDOS",
    auditorPub: "BW9DC48PHQY4NH011SHHX36DZZ3Q22Y6X7FZ1VD1CMZ2PTFZ6PN0",
    auditorBaseUrl: "https://auditor.demo.taler.net/",
    uids: ["5P25XF8TVQP9AW6VYGY2KV47WT5Y3ZXFSJAA570GJPX5SVJXKBVG"],
  },
];

const logger = new Logger("wallet.ts");

/**
 * The platform-independent wallet implementation.
 */
export class Wallet {
  private ws: InternalWalletState;
  private timerGroup: TimerGroup = new TimerGroup();
  private latch = new AsyncCondition();
  private stopped = false;
  private memoRunRetryLoop = new AsyncOpMemoSingle<void>();

  get db(): DbAccess<typeof WalletStoresV1> {
    return this.ws.db;
  }

  constructor(
    db: DbAccess<typeof WalletStoresV1>,
    http: HttpRequestLibrary,
    cryptoWorkerFactory: CryptoWorkerFactory,
  ) {
    this.ws = new InternalWalletState(db, http, cryptoWorkerFactory);
  }

  getExchangePaytoUri(
    exchangeBaseUrl: string,
    supportedTargetTypes: string[],
  ): Promise<string> {
    return getExchangePaytoUri(this.ws, exchangeBaseUrl, supportedTargetTypes);
  }

  async getWithdrawalDetailsForAmount(
    exchangeBaseUrl: string,
    amount: AmountJson,
  ): Promise<ManualWithdrawalDetails> {
    const wi = await getExchangeWithdrawalInfo(
      this.ws,
      exchangeBaseUrl,
      amount,
    );
    const paytoUris = wi.exchangeDetails.wireInfo.accounts.map(
      (x) => x.payto_uri,
    );
    if (!paytoUris) {
      throw Error("exchange is in invalid state");
    }
    return {
      amountRaw: Amounts.stringify(amount),
      amountEffective: Amounts.stringify(wi.selectedDenoms.totalCoinValue),
      paytoUris,
      tosAccepted: wi.termsOfServiceAccepted,
    };
  }

  addNotificationListener(f: (n: WalletNotification) => void): void {
    this.ws.addNotificationListener(f);
  }

  /**
   * Execute one operation based on the pending operation info record.
   */
  async processOnePendingOperation(
    pending: PendingOperationInfo,
    forceNow = false,
  ): Promise<void> {
    logger.trace(`running pending ${JSON.stringify(pending, undefined, 2)}`);
    switch (pending.type) {
      case PendingOperationType.ExchangeUpdate:
        await updateExchangeFromUrl(this.ws, pending.exchangeBaseUrl, forceNow);
        break;
      case PendingOperationType.Refresh:
        await processRefreshGroup(this.ws, pending.refreshGroupId, forceNow);
        break;
      case PendingOperationType.Reserve:
        await processReserve(this.ws, pending.reservePub, forceNow);
        break;
      case PendingOperationType.Withdraw:
        await processWithdrawGroup(
          this.ws,
          pending.withdrawalGroupId,
          forceNow,
        );
        break;
      case PendingOperationType.ProposalDownload:
        await processDownloadProposal(this.ws, pending.proposalId, forceNow);
        break;
      case PendingOperationType.TipPickup:
        await processTip(this.ws, pending.tipId, forceNow);
        break;
      case PendingOperationType.Pay:
        await processPurchasePay(this.ws, pending.proposalId, forceNow);
        break;
      case PendingOperationType.RefundQuery:
        await processPurchaseQueryRefund(this.ws, pending.proposalId, forceNow);
        break;
      case PendingOperationType.Recoup:
        await processRecoupGroup(this.ws, pending.recoupGroupId, forceNow);
        break;
      case PendingOperationType.ExchangeCheckRefresh:
        await autoRefresh(this.ws, pending.exchangeBaseUrl);
        break;
      case PendingOperationType.Deposit:
        await processDepositGroup(this.ws, pending.depositGroupId);
        break;
      default:
        assertUnreachable(pending);
    }
  }

  /**
   * Process pending operations.
   */
  public async runPending(forceNow = false): Promise<void> {
    const pendingOpsResponse = await this.getPendingOperations();
    for (const p of pendingOpsResponse.pendingOperations) {
      if (!forceNow && !isTimestampExpired(p.timestampDue)) {
        continue;
      }
      try {
        await this.processOnePendingOperation(p, forceNow);
      } catch (e) {
        if (e instanceof OperationFailedAndReportedError) {
          console.error(
            "Operation failed:",
            JSON.stringify(e.operationError, undefined, 2),
          );
        } else {
          console.error(e);
        }
      }
    }
  }

  /**
   * Run the wallet until there are no more pending operations that give
   * liveness left.  The wallet will be in a stopped state when this function
   * returns without resolving to an exception.
   */
  public async runUntilDone(
    req: {
      maxRetries?: number;
    } = {},
  ): Promise<void> {
    let done = false;
    const p = new Promise<void>((resolve, reject) => {
      // Monitor for conditions that means we're done or we
      // should quit with an error (due to exceeded retries).
      this.addNotificationListener((n) => {
        if (done) {
          return;
        }
        if (
          n.type === NotificationType.WaitingForRetry &&
          n.numGivingLiveness == 0
        ) {
          done = true;
          logger.trace("no liveness-giving operations left");
          resolve();
        }
        const maxRetries = req.maxRetries;
        if (!maxRetries) {
          return;
        }
        this.getPendingOperations()
          .then((pending) => {
            for (const p of pending.pendingOperations) {
              if (p.retryInfo && p.retryInfo.retryCounter > maxRetries) {
                console.warn(
                  `stopping, as ${maxRetries} retries are exceeded in an operation of type ${p.type}`,
                );
                this.stop();
                done = true;
                resolve();
              }
            }
          })
          .catch((e) => {
            logger.error(e);
            reject(e);
          });
      });
      // Run this asynchronously
      this.runRetryLoop().catch((e) => {
        logger.error("exception in wallet retry loop");
        reject(e);
      });
    });
    await p;
  }

  /**
   * Process pending operations and wait for scheduled operations in
   * a loop until the wallet is stopped explicitly.
   */
  public async runRetryLoop(): Promise<void> {
    // Make sure we only run one main loop at a time.
    return this.memoRunRetryLoop.memo(async () => {
      try {
        await this.runRetryLoopImpl();
      } catch (e) {
        console.error("error during retry loop execution", e);
        throw e;
      }
    });
  }

  private async runRetryLoopImpl(): Promise<void> {
    for (let iteration = 0; !this.stopped; iteration++) {
      const pending = await this.getPendingOperations();
      logger.trace(`pending operations: ${j2s(pending)}`);
      let numGivingLiveness = 0;
      let numDue = 0;
      let minDue: Timestamp = { t_ms: "never" };
      for (const p of pending.pendingOperations) {
        minDue = timestampMin(minDue, p.timestampDue);
        if (isTimestampExpired(p.timestampDue)) {
          numDue++;
        }
        if (p.givesLifeness) {
            numGivingLiveness++;
        }
      }
      // Make sure that we run tasks that don't give lifeness at least
      // one time.
      if (iteration !== 0 && numDue === 0) {
        // We've executed pending, due operations at least one.
        // Now we don't have any more operations available,
        // and need to wait.

        // Wait for at most 5 seconds to the next check.
        const dt = durationMin(
          durationFromSpec({
            seconds: 5,
          }),
          getDurationRemaining(minDue),
        );
        logger.trace(`waiting for at most ${dt.d_ms} ms`)
        const timeout = this.timerGroup.resolveAfter(dt);
        this.ws.notify({
          type: NotificationType.WaitingForRetry,
          numGivingLiveness,
          numPending: pending.pendingOperations.length,
        });
        // Wait until either the timeout, or we are notified (via the latch)
        // that more work might be available.
        await Promise.race([timeout, this.latch.wait()]);
      } else {
        logger.trace(
          `running ${pending.pendingOperations.length} pending operations`,
        );
        for (const p of pending.pendingOperations) {
          if (!isTimestampExpired(p.timestampDue)) {
            continue;
          }
          try {
            await this.processOnePendingOperation(p);
          } catch (e) {
            if (e instanceof OperationFailedAndReportedError) {
              logger.warn("operation processed resulted in reported error");
            } else {
              logger.error("Uncaught exception", e);
              this.ws.notify({
                type: NotificationType.InternalError,
                message: "uncaught exception",
                exception: e,
              });
            }
          }
          this.ws.notify({
            type: NotificationType.PendingOperationProcessed,
          });
        }
      }
    }
    logger.trace("exiting wallet retry loop");
  }

  /**
   * Insert the hard-coded defaults for exchanges, coins and
   * auditors into the database, unless these defaults have
   * already been applied.
   */
  async fillDefaults(): Promise<void> {
    await this.db
      .mktx((x) => ({ config: x.config, auditorTrustStore: x.auditorTrust }))
      .runReadWrite(async (tx) => {
        let applied = false;
        await tx.config.iter().forEach((x) => {
          if (x.key == "currencyDefaultsApplied" && x.value == true) {
            applied = true;
          }
        });
        if (!applied) {
          for (const c of builtinAuditors) {
            await tx.auditorTrustStore.put(c);
          }
        }
      });
  }

  /**
   * Check if a payment for the given taler://pay/ URI is possible.
   *
   * If the payment is possible, the signature are already generated but not
   * yet send to the merchant.
   */
  async preparePayForUri(talerPayUri: string): Promise<PreparePayResult> {
    return preparePayForUri(this.ws, talerPayUri);
  }

  /**
   * Add a contract to the wallet and sign coins, and send them.
   */
  async confirmPay(
    proposalId: string,
    sessionIdOverride: string | undefined,
  ): Promise<ConfirmPayResult> {
    try {
      return await confirmPay(this.ws, proposalId, sessionIdOverride);
    } finally {
      this.latch.trigger();
    }
  }

  /**
   * First fetch information required to withdraw from the reserve,
   * then deplete the reserve, withdrawing coins until it is empty.
   *
   * The returned promise resolves once the reserve is set to the
   * state DORMANT.
   */
  async processReserve(reservePub: string): Promise<void> {
    try {
      return await processReserve(this.ws, reservePub);
    } finally {
      this.latch.trigger();
    }
  }

  /**
   * Create a reserve, but do not flag it as confirmed yet.
   *
   * Adds the corresponding exchange as a trusted exchange if it is neither
   * audited nor trusted already.
   */
  async acceptManualWithdrawal(
    exchangeBaseUrl: string,
    amount: AmountJson,
  ): Promise<AcceptManualWithdrawalResult> {
    try {
      const resp = await createReserve(this.ws, {
        amount,
        exchange: exchangeBaseUrl,
      });
      const exchangePaytoUris = await this.db
        .mktx((x) => ({
          exchanges: x.exchanges,
          exchangeDetails: x.exchangeDetails,
          reserves: x.reserves,
        }))
        .runReadWrite((tx) => getFundingPaytoUris(tx, resp.reservePub));
      return {
        reservePub: resp.reservePub,
        exchangePaytoUris,
      };
    } finally {
      this.latch.trigger();
    }
  }

  /**
   * Check if and how an exchange is trusted and/or audited.
   */
  async getExchangeTrust(
    exchangeInfo: ExchangeRecord,
  ): Promise<{ isTrusted: boolean; isAudited: boolean }> {
    return getExchangeTrust(this.ws, exchangeInfo);
  }

  async getWithdrawalDetailsForUri(
    talerWithdrawUri: string,
  ): Promise<WithdrawUriInfoResponse> {
    return getWithdrawalDetailsForUri(this.ws, talerWithdrawUri);
  }

  async deleteTransaction(req: DeleteTransactionRequest): Promise<void> {
    return deleteTransaction(this.ws, req.transactionId);
  }

  async setDeviceId(newDeviceId: string): Promise<void> {
    return setWalletDeviceId(this.ws, newDeviceId);
  }

  /**
   * Update or add exchange DB entry by fetching the /keys and /wire information.
   */
  async updateExchangeFromUrl(
    baseUrl: string,
    force = false,
  ): Promise<{
    exchange: ExchangeRecord;
    exchangeDetails: ExchangeDetailsRecord;
  }> {
    try {
      return updateExchangeFromUrl(this.ws, baseUrl, force);
    } finally {
      this.latch.trigger();
    }
  }

  async getExchangeTos(exchangeBaseUrl: string): Promise<GetExchangeTosResult> {
    const { exchange, exchangeDetails } = await this.updateExchangeFromUrl(
      exchangeBaseUrl,
    );
    const tos = exchangeDetails.termsOfServiceText;
    const currentEtag = exchangeDetails.termsOfServiceLastEtag;
    if (!tos || !currentEtag) {
      throw Error("exchange is in invalid state");
    }
    return {
      acceptedEtag: exchangeDetails.termsOfServiceAcceptedEtag,
      currentEtag,
      tos,
    };
  }

  /**
   * Get detailed balance information, sliced by exchange and by currency.
   */
  async getBalances(): Promise<BalancesResponse> {
    return this.ws.memoGetBalance.memo(() => getBalances(this.ws));
  }

  async refresh(oldCoinPub: string): Promise<void> {
    try {
      const refreshGroupId = await this.db
        .mktx((x) => ({
          refreshGroups: x.refreshGroups,
          denominations: x.denominations,
          coins: x.coins,
        }))
        .runReadWrite(async (tx) => {
          return await createRefreshGroup(
            this.ws,
            tx,
            [{ coinPub: oldCoinPub }],
            RefreshReason.Manual,
          );
        });
      await processRefreshGroup(this.ws, refreshGroupId.refreshGroupId);
    } catch (e) {
      this.latch.trigger();
    }
  }

  async getPendingOperations(): Promise<PendingOperationsResponse> {
    return this.ws.memoGetPending.memo(() => getPendingOperations(this.ws));
  }

  async acceptExchangeTermsOfService(
    exchangeBaseUrl: string,
    etag: string | undefined,
  ): Promise<void> {
    return acceptExchangeTermsOfService(this.ws, exchangeBaseUrl, etag);
  }

  async getExchanges(): Promise<ExchangesListRespose> {
    const exchanges: ExchangeListItem[] = [];
    await this.db
      .mktx((x) => ({
        exchanges: x.exchanges,
        exchangeDetails: x.exchangeDetails,
      }))
      .runReadOnly(async (tx) => {
        const exchangeRecords = await tx.exchanges.iter().toArray();
        for (const r of exchangeRecords) {
          const dp = r.detailsPointer;
          if (!dp) {
            continue;
          }
          const { currency, masterPublicKey } = dp;
          const exchangeDetails = await getExchangeDetails(tx, r.baseUrl);
          if (!exchangeDetails) {
            continue;
          }
          exchanges.push({
            exchangeBaseUrl: r.baseUrl,
            currency,
            paytoUris: exchangeDetails.wireInfo.accounts.map(
              (x) => x.payto_uri,
            ),
          });
        }
      });
    return { exchanges };
  }

  async getCurrencies(): Promise<WalletCurrencyInfo> {
    return await this.ws.db
      .mktx((x) => ({
        auditorTrust: x.auditorTrust,
        exchangeTrust: x.exchangeTrust,
      }))
      .runReadOnly(async (tx) => {
        const trustedAuditors = await tx.auditorTrust.iter().toArray();
        const trustedExchanges = await tx.exchangeTrust.iter().toArray();
        return {
          trustedAuditors: trustedAuditors.map((x) => ({
            currency: x.currency,
            auditorBaseUrl: x.auditorBaseUrl,
            auditorPub: x.auditorPub,
          })),
          trustedExchanges: trustedExchanges.map((x) => ({
            currency: x.currency,
            exchangeBaseUrl: x.exchangeBaseUrl,
            exchangeMasterPub: x.exchangeMasterPub,
          })),
        };
      });
  }

  /**
   * Stop ongoing processing.
   */
  stop(): void {
    this.stopped = true;
    this.timerGroup.stopCurrentAndFutureTimers();
    this.ws.cryptoApi.stop();
  }

  /**
   * Trigger paying coins back into the user's account.
   */
  async returnCoins(req: ReturnCoinsRequest): Promise<void> {
    throw Error("not implemented");
  }

  /**
   * Accept a refund, return the contract hash for the contract
   * that was involved in the refund.
   */
  async applyRefund(talerRefundUri: string): Promise<ApplyRefundResponse> {
    return applyRefund(this.ws, talerRefundUri);
  }

  async acceptTip(talerTipUri: string): Promise<void> {
    try {
      return acceptTip(this.ws, talerTipUri);
    } catch (e) {
      this.latch.trigger();
    }
  }

  async prepareTip(talerTipUri: string): Promise<PrepareTipResult> {
    return prepareTip(this.ws, talerTipUri);
  }

  async abortFailedPayWithRefund(proposalId: string): Promise<void> {
    return abortFailedPayWithRefund(this.ws, proposalId);
  }

  /**
   * Inform the wallet that the status of a reserve has changed (e.g. due to a
   * confirmation from the bank.).
   */
  public async handleNotifyReserve(): Promise<void> {
    const reserves = await this.ws.db
      .mktx((x) => ({
        reserves: x.reserves,
      }))
      .runReadOnly(async (tx) => {
        return tx.reserves.iter().toArray();
      });
    for (const r of reserves) {
      if (r.reserveStatus === ReserveRecordStatus.WAIT_CONFIRM_BANK) {
        try {
          this.processReserve(r.reservePub);
        } catch (e) {
          console.error(e);
        }
      }
    }
  }

  /**
   * Remove unreferenced / expired data from the wallet's database
   * based on the current system time.
   */
  async collectGarbage(): Promise<void> {
    // FIXME(#5845)
    // We currently do not garbage-collect the wallet database.  This might change
    // after the feature has been properly re-designed, and we have come up with a
    // strategy to test it.
  }

  async acceptWithdrawal(
    talerWithdrawUri: string,
    selectedExchange: string,
  ): Promise<AcceptWithdrawalResponse> {
    try {
      return createTalerWithdrawReserve(
        this.ws,
        talerWithdrawUri,
        selectedExchange,
      );
    } finally {
      this.latch.trigger();
    }
  }

  async refuseProposal(proposalId: string): Promise<void> {
    return refuseProposal(this.ws, proposalId);
  }

  benchmarkCrypto(repetitions: number): Promise<BenchmarkResult> {
    return this.ws.cryptoApi.benchmark(repetitions);
  }

  async setCoinSuspended(coinPub: string, suspended: boolean): Promise<void> {
    await this.db
      .mktx((x) => ({
        coins: x.coins,
      }))
      .runReadWrite(async (tx) => {
        const c = await tx.coins.get(coinPub);
        if (!c) {
          logger.warn(`coin ${coinPub} not found, won't suspend`);
          return;
        }
        c.suspended = suspended;
        await tx.coins.put(c);
      });
  }

  /**
   * Dump the public information of coins we have in an easy-to-process format.
   */
  async dumpCoins(): Promise<CoinDumpJson> {
    const coinsJson: CoinDumpJson = { coins: [] };
    await this.ws.db
      .mktx((x) => ({
        coins: x.coins,
        denominations: x.denominations,
        withdrawalGroups: x.withdrawalGroups,
      }))
      .runReadOnly(async (tx) => {
        const coins = await tx.coins.iter().toArray();
        for (const c of coins) {
          const denom = await tx.denominations.get([
            c.exchangeBaseUrl,
            c.denomPubHash,
          ]);
          if (!denom) {
            console.error("no denom session found for coin");
            continue;
          }
          const cs = c.coinSource;
          let refreshParentCoinPub: string | undefined;
          if (cs.type == CoinSourceType.Refresh) {
            refreshParentCoinPub = cs.oldCoinPub;
          }
          let withdrawalReservePub: string | undefined;
          if (cs.type == CoinSourceType.Withdraw) {
            const ws = await tx.withdrawalGroups.get(cs.withdrawalGroupId);
            if (!ws) {
              console.error("no withdrawal session found for coin");
              continue;
            }
            withdrawalReservePub = ws.reservePub;
          }
          coinsJson.coins.push({
            coin_pub: c.coinPub,
            denom_pub: c.denomPub,
            denom_pub_hash: c.denomPubHash,
            denom_value: Amounts.stringify(denom.value),
            exchange_base_url: c.exchangeBaseUrl,
            refresh_parent_coin_pub: refreshParentCoinPub,
            remaining_value: Amounts.stringify(c.currentAmount),
            withdrawal_reserve_pub: withdrawalReservePub,
            coin_suspended: c.suspended,
          });
        }
      });
    return coinsJson;
  }

  async getTransactions(
    request: TransactionsRequest,
  ): Promise<TransactionsResponse> {
    return getTransactions(this.ws, request);
  }

  async withdrawTestBalance(req: WithdrawTestBalanceRequest): Promise<void> {
    await withdrawTestBalance(
      this.ws,
      req.amount,
      req.bankBaseUrl,
      req.exchangeBaseUrl,
    );
  }

  async updateReserve(reservePub: string): Promise<ReserveRecord | undefined> {
    await forceQueryReserve(this.ws, reservePub);
    return await this.ws.db
      .mktx((x) => ({
        reserves: x.reserves,
      }))
      .runReadOnly(async (tx) => {
        return tx.reserves.get(reservePub);
      });
  }

  async getCoins(): Promise<CoinRecord[]> {
    return await this.db
      .mktx((x) => ({
        coins: x.coins,
      }))
      .runReadOnly(async (tx) => {
        return tx.coins.iter().toArray();
      });
  }

  async getReservesForExchange(
    exchangeBaseUrl?: string,
  ): Promise<ReserveRecord[]> {
    return await this.db
      .mktx((x) => ({
        reserves: x.reserves,
      }))
      .runReadOnly(async (tx) => {
        if (exchangeBaseUrl) {
          return await tx.reserves
            .iter()
            .filter((r) => r.exchangeBaseUrl === exchangeBaseUrl);
        } else {
          return await tx.reserves.iter().toArray();
        }
      });
  }

  async getReserve(reservePub: string): Promise<ReserveRecord | undefined> {
    return await this.db
      .mktx((x) => ({
        reserves: x.reserves,
      }))
      .runReadOnly(async (tx) => {
        return tx.reserves.get(reservePub);
      });
  }

  async runIntegrationtest(args: IntegrationTestArgs): Promise<void> {
    return runIntegrationTest(this.ws.http, this, args);
  }

  async testPay(args: TestPayArgs) {
    return testPay(this.ws.http, this, args);
  }

  async exportBackupPlain() {
    return exportBackup(this.ws);
  }

  async importBackupPlain(backup: any) {
    return importBackupPlain(this.ws, backup);
  }

  async exportBackupEncrypted() {
    return exportBackupEncrypted(this.ws);
  }

  async importBackupEncrypted(backup: Uint8Array) {
    return importBackupEncrypted(this.ws, backup);
  }

  async getBackupRecovery(): Promise<BackupRecovery> {
    return getBackupRecovery(this.ws);
  }

  async loadBackupRecovery(req: RecoveryLoadRequest): Promise<void> {
    return loadBackupRecovery(this.ws, req);
  }

  async addBackupProvider(req: AddBackupProviderRequest): Promise<void> {
    return addBackupProvider(this.ws, req);
  }

  async createDepositGroup(
    req: CreateDepositGroupRequest,
  ): Promise<CreateDepositGroupResponse> {
    return createDepositGroup(this.ws, req);
  }

  async runBackupCycle(): Promise<void> {
    return runBackupCycle(this.ws);
  }

  async getBackupStatus(): Promise<BackupInfo> {
    return getBackupInfo(this.ws);
  }

  async trackDepositGroup(
    req: TrackDepositGroupRequest,
  ): Promise<TrackDepositGroupResponse> {
    return trackDepositGroup(this.ws, req);
  }

  /**
   * Implementation of the "wallet-core" API.
   */
  private async dispatchRequestInternal(
    operation: string,
    payload: unknown,
  ): Promise<Record<string, any>> {
    switch (operation) {
      case "withdrawTestkudos": {
        await this.withdrawTestBalance({
          amount: "TESTKUDOS:10",
          bankBaseUrl: "https://bank.test.taler.net/",
          exchangeBaseUrl: "https://exchange.test.taler.net/",
        });
        return {};
      }
      case "withdrawTestBalance": {
        const req = codecForWithdrawTestBalance().decode(payload);
        await this.withdrawTestBalance(req);
        return {};
      }
      case "runIntegrationTest": {
        const req = codecForIntegrationTestArgs().decode(payload);
        await this.runIntegrationtest(req);
        return {};
      }
      case "testPay": {
        const req = codecForTestPayArgs().decode(payload);
        await this.testPay(req);
        return {};
      }
      case "getTransactions": {
        const req = codecForTransactionsRequest().decode(payload);
        return await this.getTransactions(req);
      }
      case "addExchange": {
        const req = codecForAddExchangeRequest().decode(payload);
        await this.updateExchangeFromUrl(req.exchangeBaseUrl);
        return {};
      }
      case "forceUpdateExchange": {
        const req = codecForForceExchangeUpdateRequest().decode(payload);
        await this.updateExchangeFromUrl(req.exchangeBaseUrl, true);
        return {};
      }
      case "listExchanges": {
        return await this.getExchanges();
      }
      case "getWithdrawalDetailsForUri": {
        const req = codecForGetWithdrawalDetailsForUri().decode(payload);
        return await this.getWithdrawalDetailsForUri(req.talerWithdrawUri);
      }
      case "acceptManualWithdrawal": {
        const req = codecForAcceptManualWithdrawalRequet().decode(payload);
        const res = await this.acceptManualWithdrawal(
          req.exchangeBaseUrl,
          Amounts.parseOrThrow(req.amount),
        );
        return res;
      }
      case "getWithdrawalDetailsForAmount": {
        const req = codecForGetWithdrawalDetailsForAmountRequest().decode(
          payload,
        );
        return await this.getWithdrawalDetailsForAmount(
          req.exchangeBaseUrl,
          Amounts.parseOrThrow(req.amount),
        );
      }
      case "getBalances": {
        return await this.getBalances();
      }
      case "getPendingOperations": {
        return await this.getPendingOperations();
      }
      case "setExchangeTosAccepted": {
        const req = codecForAcceptExchangeTosRequest().decode(payload);
        await this.acceptExchangeTermsOfService(req.exchangeBaseUrl, req.etag);
        return {};
      }
      case "applyRefund": {
        const req = codecForApplyRefundRequest().decode(payload);
        return await this.applyRefund(req.talerRefundUri);
      }
      case "acceptBankIntegratedWithdrawal": {
        const req = codecForAcceptBankIntegratedWithdrawalRequest().decode(
          payload,
        );
        return await this.acceptWithdrawal(
          req.talerWithdrawUri,
          req.exchangeBaseUrl,
        );
      }
      case "getExchangeTos": {
        const req = codecForGetExchangeTosRequest().decode(payload);
        return this.getExchangeTos(req.exchangeBaseUrl);
      }
      case "retryPendingNow": {
        await this.runPending(true);
        return {};
      }
      case "preparePay": {
        const req = codecForPreparePayRequest().decode(payload);
        return await this.preparePayForUri(req.talerPayUri);
      }
      case "confirmPay": {
        const req = codecForConfirmPayRequest().decode(payload);
        return await this.confirmPay(req.proposalId, req.sessionId);
      }
      case "abortFailedPayWithRefund": {
        const req = codecForAbortPayWithRefundRequest().decode(payload);
        await this.abortFailedPayWithRefund(req.proposalId);
        return {};
      }
      case "dumpCoins": {
        return await this.dumpCoins();
      }
      case "setCoinSuspended": {
        const req = codecForSetCoinSuspendedRequest().decode(payload);
        await this.setCoinSuspended(req.coinPub, req.suspended);
        return {};
      }
      case "forceRefresh": {
        const req = codecForForceRefreshRequest().decode(payload);
        const coinPubs = req.coinPubList.map((x) => ({ coinPub: x }));
        const refreshGroupId = await this.db
          .mktx((x) => ({
            refreshGroups: x.refreshGroups,
            denominations: x.denominations,
            coins: x.coins,
          }))
          .runReadWrite(async (tx) => {
            return await createRefreshGroup(
              this.ws,
              tx,
              coinPubs,
              RefreshReason.Manual,
            );
          });
        return {
          refreshGroupId,
        };
      }
      case "prepareTip": {
        const req = codecForPrepareTipRequest().decode(payload);
        return await this.prepareTip(req.talerTipUri);
      }
      case "acceptTip": {
        const req = codecForAcceptTipRequest().decode(payload);
        await this.acceptTip(req.walletTipId);
        return {};
      }
      case "exportBackup": {
        return exportBackup(this.ws);
      }
      case "addBackupProvider": {
        const req = codecForAddBackupProviderRequest().decode(payload);
        await addBackupProvider(this.ws, req);
        return {};
      }
      case "runBackupCycle": {
        await runBackupCycle(this.ws);
        return {};
      }
      case "exportBackupRecovery": {
        const resp = await getBackupRecovery(this.ws);
        return resp;
      }
      case "importBackupRecovery": {
        const req = codecForAny().decode(payload);
        await loadBackupRecovery(this.ws, req);
        return {};
      }
      case "getBackupInfo": {
        const resp = await getBackupInfo(this.ws);
        return resp;
      }
      case "createDepositGroup": {
        const req = codecForCreateDepositGroupRequest().decode(payload);
        return await createDepositGroup(this.ws, req);
      }
      case "trackDepositGroup": {
        const req = codecForTrackDepositGroupRequest().decode(payload);
        return trackDepositGroup(this.ws, req);
      }
      case "deleteTransaction": {
        const req = codecForDeleteTransactionRequest().decode(payload);
        await deleteTransaction(this.ws, req.transactionId);
        return {};
      }
      case "retryTransaction": {
        const req = codecForRetryTransactionRequest().decode(payload);
        await retryTransaction(this.ws, req.transactionId);
        return {};
      }
    }
    throw OperationFailedError.fromCode(
      TalerErrorCode.WALLET_CORE_API_OPERATION_UNKNOWN,
      "unknown operation",
      {
        operation,
      },
    );
  }

  /**
   * Handle a request to the wallet-core API.
   */
  async handleCoreApiRequest(
    operation: string,
    id: string,
    payload: unknown,
  ): Promise<CoreApiResponse> {
    try {
      const result = await this.dispatchRequestInternal(operation, payload);
      return {
        type: "response",
        operation,
        id,
        result,
      };
    } catch (e) {
      if (
        e instanceof OperationFailedError ||
        e instanceof OperationFailedAndReportedError
      ) {
        return {
          type: "error",
          operation,
          id,
          error: e.operationError,
        };
      } else {
        return {
          type: "error",
          operation,
          id,
          error: makeErrorDetails(
            TalerErrorCode.WALLET_UNEXPECTED_EXCEPTION,
            `unexpected exception: ${e}`,
            {},
          ),
        };
      }
    }
  }
}