aboutsummaryrefslogtreecommitdiff
path: root/src/wallet.ts
diff options
context:
space:
mode:
Diffstat (limited to 'src/wallet.ts')
-rw-r--r--src/wallet.ts881
1 files changed, 0 insertions, 881 deletions
diff --git a/src/wallet.ts b/src/wallet.ts
deleted file mode 100644
index 4d22bd591..000000000
--- a/src/wallet.ts
+++ /dev/null
@@ -1,881 +0,0 @@
-/*
- 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 { CryptoWorkerFactory } from "./crypto/workers/cryptoApi";
-import { HttpRequestLibrary } from "./util/http";
-import { Database } from "./util/query";
-
-import { Amounts, AmountJson } from "./util/amounts";
-
-import {
- getExchangeWithdrawalInfo,
- getWithdrawalDetailsForUri,
-} from "./operations/withdraw";
-
-import {
- preparePayForUri,
- refuseProposal,
- confirmPay,
- processDownloadProposal,
- processPurchasePay,
-} from "./operations/pay";
-
-import {
- CoinRecord,
- CurrencyRecord,
- DenominationRecord,
- ExchangeRecord,
- PurchaseRecord,
- ReserveRecord,
- Stores,
- ReserveRecordStatus,
- CoinSourceType,
- RefundState,
-} from "./types/dbTypes";
-import { CoinDumpJson, WithdrawUriInfoResponse } from "./types/talerTypes";
-import {
- BenchmarkResult,
- ConfirmPayResult,
- ReturnCoinsRequest,
- SenderWireInfos,
- TipStatus,
- PreparePayResult,
- AcceptWithdrawalResponse,
- PurchaseDetails,
- RefreshReason,
- ExchangeListItem,
- ExchangesListRespose,
- ManualWithdrawalDetails,
- GetExchangeTosResult,
- AcceptManualWithdrawalResult,
- BalancesResponse,
-} from "./types/walletTypes";
-import { Logger } from "./util/logging";
-
-import { assertUnreachable } from "./util/assertUnreachable";
-
-import {
- updateExchangeFromUrl,
- getExchangeTrust,
- getExchangePaytoUri,
- acceptExchangeTermsOfService,
-} from "./operations/exchanges";
-import {
- processReserve,
- createTalerWithdrawReserve,
- forceQueryReserve,
- getFundingPaytoUris,
-} from "./operations/reserves";
-
-import { InternalWalletState } from "./operations/state";
-import { createReserve } from "./operations/reserves";
-import { processRefreshGroup, createRefreshGroup } from "./operations/refresh";
-import { processWithdrawGroup } from "./operations/withdraw";
-import { getPendingOperations } from "./operations/pending";
-import { getBalances } from "./operations/balance";
-import { acceptTip, getTipStatus, processTip } from "./operations/tip";
-import { TimerGroup } from "./util/timer";
-import { AsyncCondition } from "./util/promiseUtils";
-import { AsyncOpMemoSingle } from "./util/asyncMemo";
-import {
- PendingOperationInfo,
- PendingOperationsResponse,
- PendingOperationType,
-} from "./types/pending";
-import { WalletNotification, NotificationType } from "./types/notifications";
-import { processPurchaseQueryRefund, applyRefund } from "./operations/refund";
-import { durationMin, Duration } from "./util/time";
-import { processRecoupGroup } from "./operations/recoup";
-import { OperationFailedAndReportedError } from "./operations/errors";
-import {
- TransactionsRequest,
- TransactionsResponse,
-} from "./types/transactions";
-import { getTransactions } from "./operations/transactions";
-import { withdrawTestBalance } from "./operations/testing";
-
-const builtinCurrencies: CurrencyRecord[] = [
- {
- auditors: [
- {
- auditorPub: "BW9DC48PHQY4NH011SHHX36DZZ3Q22Y6X7FZ1VD1CMZ2PTFZ6PN0",
- baseUrl: "https://auditor.demo.taler.net/",
- expirationStamp: new Date(2027, 1).getTime(),
- },
- ],
- exchanges: [],
- fractionalDigits: 2,
- name: "KUDOS",
- },
-];
-
-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(): Database {
- return this.ws.db;
- }
-
- constructor(
- db: Database,
- 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.exchangeInfo.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.Bug:
- // Nothing to do, will just be displayed to the user
- return;
- 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.ProposalChoice:
- // Nothing to do, user needs to accept/reject
- break;
- case PendingOperationType.ProposalDownload:
- await processDownloadProposal(this.ws, pending.proposalId, forceNow);
- break;
- case PendingOperationType.TipChoice:
- // Nothing to do, user needs to accept/reject
- 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;
- default:
- assertUnreachable(pending);
- }
- }
-
- /**
- * Process pending operations.
- */
- public async runPending(forceNow = false): Promise<void> {
- const onlyDue = !forceNow;
- const pendingOpsResponse = await this.getPendingOperations({ onlyDue });
- for (const p of pendingOpsResponse.pendingOperations) {
- 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(): Promise<void> {
- let done = false;
- const p = new Promise((resolve, reject) => {
- // Run this asynchronously
- this.addNotificationListener((n) => {
- if (done) {
- return;
- }
- if (
- n.type === NotificationType.WaitingForRetry &&
- n.numGivingLiveness == 0
- ) {
- done = true;
- logger.trace("no liveness-giving operations left");
- resolve();
- }
- });
- this.runRetryLoop().catch((e) => {
- console.log("exception in wallet retry loop");
- reject(e);
- });
- });
- await p;
- }
-
- /**
- * 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 runUntilDoneAndStop(): Promise<void> {
- await this.runUntilDone();
- logger.trace("stopping after liveness-giving operations done");
- this.stop();
- }
-
- /**
- * 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> {
- while (!this.stopped) {
- const pending = await this.getPendingOperations({ onlyDue: true });
- if (pending.pendingOperations.length === 0) {
- const allPending = await this.getPendingOperations({ onlyDue: false });
- let numPending = 0;
- let numGivingLiveness = 0;
- for (const p of allPending.pendingOperations) {
- numPending++;
- if (p.givesLifeness) {
- numGivingLiveness++;
- }
- }
- let dt: Duration;
- if (
- allPending.pendingOperations.length === 0 ||
- allPending.nextRetryDelay.d_ms === Number.MAX_SAFE_INTEGER
- ) {
- // Wait for 5 seconds
- dt = { d_ms: 5000 };
- } else {
- dt = durationMin({ d_ms: 5000 }, allPending.nextRetryDelay);
- }
- const timeout = this.timerGroup.resolveAfter(dt);
- this.ws.notify({
- type: NotificationType.WaitingForRetry,
- numGivingLiveness,
- numPending,
- });
- await Promise.race([timeout, this.latch.wait()]);
- console.log("timeout done");
- } else {
- // FIXME: maybe be a bit smarter about executing these
- // operations in parallel?
- for (const p of pending.pendingOperations) {
- try {
- await this.processOnePendingOperation(p);
- } catch (e) {
- if (e instanceof OperationFailedAndReportedError) {
- logger.warn("operation processed resulted in reported error");
- } else {
- console.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.runWithWriteTransaction(
- [Stores.config, Stores.currencies],
- async (tx) => {
- let applied = false;
- await tx.iter(Stores.config).forEach((x) => {
- if (x.key == "currencyDefaultsApplied" && x.value == true) {
- applied = true;
- }
- });
- if (!applied) {
- for (const c of builtinCurrencies) {
- await tx.put(Stores.currencies, 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 requred 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.runWithReadTransaction(
- [Stores.exchanges, Stores.reserves],
- (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);
- }
-
- /**
- * Update or add exchange DB entry by fetching the /keys and /wire information.
- * Optionally link the reserve entry to the new or existing
- * exchange entry in then DB.
- */
- async updateExchangeFromUrl(
- baseUrl: string,
- force = false,
- ): Promise<ExchangeRecord> {
- try {
- return updateExchangeFromUrl(this.ws, baseUrl, force);
- } finally {
- this.latch.trigger();
- }
- }
-
- async getExchangeTos(exchangeBaseUrl: string): Promise<GetExchangeTosResult> {
- const exchange = await this.updateExchangeFromUrl(exchangeBaseUrl);
- const tos = exchange.termsOfServiceText;
- const currentEtag = exchange.termsOfServiceLastEtag;
- if (!tos || !currentEtag) {
- throw Error("exchange is in invalid state");
- }
- return {
- acceptedEtag: exchange.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.runWithWriteTransaction(
- [Stores.refreshGroups],
- async (tx) => {
- return await createRefreshGroup(
- this.ws,
- tx,
- [{ coinPub: oldCoinPub }],
- RefreshReason.Manual,
- );
- },
- );
- await processRefreshGroup(this.ws, refreshGroupId.refreshGroupId);
- } catch (e) {
- this.latch.trigger();
- }
- }
-
- async findExchange(
- exchangeBaseUrl: string,
- ): Promise<ExchangeRecord | undefined> {
- return await this.db.get(Stores.exchanges, exchangeBaseUrl);
- }
-
- async getPendingOperations({ onlyDue = false } = {}): Promise<
- PendingOperationsResponse
- > {
- return this.ws.memoGetPending.memo(() =>
- getPendingOperations(this.ws, { onlyDue }),
- );
- }
-
- async acceptExchangeTermsOfService(
- exchangeBaseUrl: string,
- etag: string | undefined,
- ): Promise<void> {
- return acceptExchangeTermsOfService(this.ws, exchangeBaseUrl, etag);
- }
-
- async getDenoms(exchangeUrl: string): Promise<DenominationRecord[]> {
- const denoms = await this.db
- .iterIndex(Stores.denominations.exchangeBaseUrlIndex, exchangeUrl)
- .toArray();
- return denoms;
- }
-
- /**
- * Get all exchanges known to the exchange.
- *
- * @deprecated Use getExchanges instead
- */
- async getExchangeRecords(): Promise<ExchangeRecord[]> {
- return await this.db.iter(Stores.exchanges).toArray();
- }
-
- async getExchanges(): Promise<ExchangesListRespose> {
- const exchanges: (ExchangeListItem | undefined)[] = await this.db
- .iter(Stores.exchanges)
- .map((x) => {
- const details = x.details;
- if (!details) {
- return undefined;
- }
- if (!x.addComplete) {
- return undefined;
- }
- if (!x.wireInfo) {
- return undefined;
- }
- return {
- exchangeBaseUrl: x.baseUrl,
- currency: details.currency,
- paytoUris: x.wireInfo.accounts.map((x) => x.payto_uri),
- };
- });
- return {
- exchanges: exchanges.filter((x) => !!x) as ExchangeListItem[],
- };
- }
-
- async getCurrencies(): Promise<CurrencyRecord[]> {
- return await this.db.iter(Stores.currencies).toArray();
- }
-
- async updateCurrency(currencyRecord: CurrencyRecord): Promise<void> {
- logger.trace("updating currency to", currencyRecord);
- await this.db.put(Stores.currencies, currencyRecord);
- }
-
- async getReserves(exchangeBaseUrl?: string): Promise<ReserveRecord[]> {
- if (exchangeBaseUrl) {
- return await this.db
- .iter(Stores.reserves)
- .filter((r) => r.exchangeBaseUrl === exchangeBaseUrl);
- } else {
- return await this.db.iter(Stores.reserves).toArray();
- }
- }
-
- async getCoinsForExchange(exchangeBaseUrl: string): Promise<CoinRecord[]> {
- return await this.db
- .iter(Stores.coins)
- .filter((c) => c.exchangeBaseUrl === exchangeBaseUrl);
- }
-
- async getCoins(): Promise<CoinRecord[]> {
- return await this.db.iter(Stores.coins).toArray();
- }
-
- /**
- * Stop ongoing processing.
- */
- stop(): void {
- this.stopped = true;
- this.timerGroup.stopCurrentAndFutureTimers();
- this.ws.cryptoApi.stop();
- }
-
- async getSenderWireInfos(): Promise<SenderWireInfos> {
- const m: { [url: string]: Set<string> } = {};
-
- await this.db.iter(Stores.exchanges).forEach((x) => {
- const wi = x.wireInfo;
- if (!wi) {
- return;
- }
- const s = (m[x.baseUrl] = m[x.baseUrl] || new Set());
- Object.keys(wi.feesForType).map((k) => s.add(k));
- });
-
- const exchangeWireTypes: { [url: string]: string[] } = {};
- Object.keys(m).map((e) => {
- exchangeWireTypes[e] = Array.from(m[e]);
- });
-
- const senderWiresSet: Set<string> = new Set();
- await this.db.iter(Stores.senderWires).forEach((x) => {
- senderWiresSet.add(x.paytoUri);
- });
-
- const senderWires: string[] = Array.from(senderWiresSet);
-
- return {
- exchangeWireTypes,
- senderWires,
- };
- }
-
- /**
- * 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<{ contractTermsHash: string; proposalId: string }> {
- return applyRefund(this.ws, talerRefundUri);
- }
-
- async getPurchase(
- contractTermsHash: string,
- ): Promise<PurchaseRecord | undefined> {
- return this.db.get(Stores.purchases, contractTermsHash);
- }
-
- async acceptTip(talerTipUri: string): Promise<void> {
- try {
- return acceptTip(this.ws, talerTipUri);
- } catch (e) {
- this.latch.trigger();
- }
- }
-
- async getTipStatus(talerTipUri: string): Promise<TipStatus> {
- return getTipStatus(this.ws, talerTipUri);
- }
-
- async abortFailedPayment(contractTermsHash: string): Promise<void> {
- throw Error("not implemented");
- }
-
- /**
- * 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.db.iter(Stores.reserves).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 updateReserve(reservePub: string): Promise<ReserveRecord | undefined> {
- await forceQueryReserve(this.ws, reservePub);
- return await this.ws.db.get(Stores.reserves, reservePub);
- }
-
- async getReserve(reservePub: string): Promise<ReserveRecord | undefined> {
- return await this.ws.db.get(Stores.reserves, reservePub);
- }
-
- async refuseProposal(proposalId: string): Promise<void> {
- return refuseProposal(this.ws, proposalId);
- }
-
- async getPurchaseDetails(proposalId: string): Promise<PurchaseDetails> {
- const purchase = await this.db.get(Stores.purchases, proposalId);
- if (!purchase) {
- throw Error("unknown purchase");
- }
- const refundsDoneAmounts = Object.values(purchase.refunds)
- .filter((x) => x.type === RefundState.Applied)
- .map((x) => x.refundAmount);
-
- const refundsPendingAmounts = Object.values(purchase.refunds)
- .filter((x) => x.type === RefundState.Pending)
- .map((x) => x.refundAmount);
- const totalRefundAmount = Amounts.sum([
- ...refundsDoneAmounts,
- ...refundsPendingAmounts,
- ]).amount;
- const refundsDoneFees = Object.values(purchase.refunds)
- .filter((x) => x.type === RefundState.Applied)
- .map((x) => x.refundFee);
- const refundsPendingFees = Object.values(purchase.refunds)
- .filter((x) => x.type === RefundState.Pending)
- .map((x) => x.refundFee);
- const totalRefundFees = Amounts.sum([
- ...refundsDoneFees,
- ...refundsPendingFees,
- ]).amount;
- const totalFees = totalRefundFees;
- return {
- contractTerms: JSON.parse(purchase.contractTermsRaw),
- hasRefund: purchase.timestampLastRefundStatus !== undefined,
- totalRefundAmount: totalRefundAmount,
- totalRefundAndRefreshFees: totalFees,
- };
- }
-
- benchmarkCrypto(repetitions: number): Promise<BenchmarkResult> {
- return this.ws.cryptoApi.benchmark(repetitions);
- }
-
- async setCoinSuspended(coinPub: string, suspended: boolean): Promise<void> {
- await this.db.runWithWriteTransaction([Stores.coins], async (tx) => {
- const c = await tx.get(Stores.coins, coinPub);
- if (!c) {
- logger.warn(`coin ${coinPub} not found, won't suspend`);
- return;
- }
- c.suspended = suspended;
- await tx.put(Stores.coins, c);
- });
- }
-
- /**
- * Dump the public information of coins we have in an easy-to-process format.
- */
- async dumpCoins(): Promise<CoinDumpJson> {
- const coins = await this.db.iter(Stores.coins).toArray();
- const coinsJson: CoinDumpJson = { coins: [] };
- for (const c of coins) {
- const denom = await this.db.get(Stores.denominations, [
- c.exchangeBaseUrl,
- c.denomPub,
- ]);
- 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 this.db.get(
- Stores.withdrawalGroups,
- cs.withdrawalGroupId,
- );
- if (!ws) {
- console.error("no withdrawal session found for coin");
- continue;
- }
- if (ws.source.type == "reserve") {
- withdrawalReservePub = ws.source.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(
- amount = "TESTKUDOS:10",
- bankBaseUrl = "https://bank.test.taler.net/",
- exchangeBaseUrl = "https://exchange.test.taler.net/",
- ): Promise<void> {
- await withdrawTestBalance(this.ws, amount, bankBaseUrl, exchangeBaseUrl);
- }
-}