[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[taler-docs] 01/02: diagrams
|
From: |
gnunet |
|
Subject: |
[taler-docs] 01/02: diagrams |
|
Date: |
Sat, 29 Apr 2023 17:02:46 +0200 |
This is an automated email from the git hooks/post-receive script.
dold pushed a commit to branch master
in repository docs.
commit b04649eb0fe7a223b397a8ffb2bc3c6132af76d7
Author: Florian Dold <florian@dold.me>
AuthorDate: Wed Apr 26 09:13:23 2023 +0200
diagrams
---
.../037-wallet-transactions-lifecycle.rst | 5 +-
extract-tsdefs/foo | 3562 ++++++++++++++++++++
transaction-deposit-states.dot | 79 +-
transaction-refresh-states.dot | 35 +-
transaction-refund-states.dot | 28 +-
transaction-tip-states.dot | 73 +-
6 files changed, 3654 insertions(+), 128 deletions(-)
diff --git a/design-documents/037-wallet-transactions-lifecycle.rst
b/design-documents/037-wallet-transactions-lifecycle.rst
index 5a26dea..9355de5 100644
--- a/design-documents/037-wallet-transactions-lifecycle.rst
+++ b/design-documents/037-wallet-transactions-lifecycle.rst
@@ -129,7 +129,7 @@ offered.
.. image:: ../transaction-common-states.png
- :width: 400
+ :width: 800
Boxed labels indicate an end state in which there is no network activity and
@@ -507,7 +507,6 @@ payment transaction.
The refund failed permanently.
.. image:: ../transaction-refund-states.png
- :width: 400
Transaction Type: Refresh
@@ -560,7 +559,6 @@ the same as if the double-spending transaction had been
deleted by the user.
fresh coins are preserved.
.. image:: ../transaction-refresh-states.png
- :width: 250
@@ -637,7 +635,6 @@ Transaction Type: Tip
coins are preserved.
.. image:: ../transaction-tip-states.png
- :width: 600
Transaction Type: Deposit
diff --git a/extract-tsdefs/foo b/extract-tsdefs/foo
new file mode 100644
index 0000000..ade427c
--- /dev/null
+++ b/extract-tsdefs/foo
@@ -0,0 +1,3562 @@
+# Wallet-Core API Documentation
+This file is auto-generated from
[wallet-core](https://git.taler.net/wallet-core.git/tree/packages/taler-wallet-core/src/wallet-api-types.ts).
+## Overview
+### Unknown Group
+* [InitWalletOp](#initwalletop)
+* [GetVersionOp](#getversionop)
+### Basic Wallet Information
+* [GetBalancesOp](#getbalancesop)
+* [GetBalancesDetailOp](#getbalancesdetailop)
+### Managing Transactions
+* [GetTransactionsOp](#gettransactionsop)
+* [GetTransactionByIdOp](#gettransactionbyidop)
+* [RetryPendingNowOp](#retrypendingnowop)
+* [DeleteTransactionOp](#deletetransactionop)
+* [RetryTransactionOp](#retrytransactionop)
+* [AbortTransactionOp](#aborttransactionop)
+* [SuspendTransactionOp](#suspendtransactionop)
+* [ResumeTransactionOp](#resumetransactionop)
+### Withdrawals
+* [GetWithdrawalDetailsForAmountOp](#getwithdrawaldetailsforamountop)
+* [GetWithdrawalDetailsForUriOp](#getwithdrawaldetailsforuriop)
+* [AcceptBankIntegratedWithdrawalOp](#acceptbankintegratedwithdrawalop)
+* [AcceptManualWithdrawalOp](#acceptmanualwithdrawalop)
+### Merchant Payments
+* [PreparePayForUriOp](#preparepayforuriop)
+* [PreparePayForTemplateOp](#preparepayfortemplateop)
+* [GetContractTermsDetailsOp](#getcontracttermsdetailsop)
+* [ConfirmPayOp](#confirmpayop)
+* [ApplyRefundOp](#applyrefundop)
+* [ApplyRefundFromPurchaseIdOp](#applyrefundfrompurchaseidop)
+* [PrepareRefundOp](#preparerefundop)
+### Tipping
+* [PrepareTipOp](#preparetipop)
+* [AcceptTipOp](#accepttipop)
+### Exchange Management
+* [ListExchangesOp](#listexchangesop)
+* [AddExchangeOp](#addexchangeop)
+* [ListKnownBankAccountsOp](#listknownbankaccountsop)
+* [AddKnownBankAccountsOp](#addknownbankaccountsop)
+* [ForgetKnownBankAccountsOp](#forgetknownbankaccountsop)
+* [SetExchangeTosAcceptedOp](#setexchangetosacceptedop)
+* [GetExchangeTosOp](#getexchangetosop)
+* [GetExchangeDetailedInfoOp](#getexchangedetailedinfoop)
+* [ListCurrenciesOp](#listcurrenciesop)
+### Deposits
+* [GenerateDepositGroupTxIdOp](#generatedepositgrouptxidop)
+* [CreateDepositGroupOp](#createdepositgroupop)
+* [PrepareDepositOp](#preparedepositop)
+### Backups
+* [ExportBackupRecoveryOp](#exportbackuprecoveryop)
+* [ImportBackupRecoveryOp](#importbackuprecoveryop)
+* [RunBackupCycleOp](#runbackupcycleop)
+* [ExportBackupOp](#exportbackupop)
+* [AddBackupProviderOp](#addbackupproviderop)
+* [RemoveBackupProviderOp](#removebackupproviderop)
+* [GetBackupInfoOp](#getbackupinfoop)
+* [SetWalletDeviceIdOp](#setwalletdeviceidop)
+* [ExportBackupPlainOp](#exportbackupplainop)
+### Peer Payments
+* [CheckPeerPushDebitOp](#checkpeerpushdebitop)
+* [InitiatePeerPushDebitOp](#initiatepeerpushdebitop)
+* [PreparePeerPushCreditOp](#preparepeerpushcreditop)
+* [ConfirmPeerPushCreditOp](#confirmpeerpushcreditop)
+* [CheckPeerPullCreditOp](#checkpeerpullcreditop)
+* [InitiatePeerPullCreditOp](#initiatepeerpullcreditop)
+* [PreparePeerPullDebitOp](#preparepeerpulldebitop)
+* [ConfirmPeerPullDebitOp](#confirmpeerpulldebitop)
+### Data Validation
+* [ValidateIbanOp](#validateibanop)
+### Database Management
+* [ExportDbOp](#exportdbop)
+* [ImportDbOp](#importdbop)
+* [ClearDbOp](#cleardbop)
+* [RecycleOp](#recycleop)
+### Testing and Debugging
+* [ApplyDevExperimentOp](#applydevexperimentop)
+* [RunIntegrationTestOp](#runintegrationtestop)
+* [RunIntegrationTestV2Op](#runintegrationtestv2op)
+* [TestCryptoOp](#testcryptoop)
+* [WithdrawTestBalanceOp](#withdrawtestbalanceop)
+* [WithdrawTestkudosOp](#withdrawtestkudosop)
+* [TestPayOp](#testpayop)
+* [WithdrawFakebankOp](#withdrawfakebankop)
+* [GetPendingTasksOp](#getpendingtasksop)
+* [DumpCoinsOp](#dumpcoinsop)
+* [SetCoinSuspendedOp](#setcoinsuspendedop)
+* [ForceRefreshOp](#forcerefreshop)
+## Operation Reference
+### InitWalletOp
+```typescript
+/**
+ * Initialize wallet-core.
+ *
+ * Must be the request before any other operations.
+ */
+export type InitWalletOp = {
+ op: WalletApiOperation.InitWallet;
+ request: InitRequest;
+ response: InitResponse;
+};
+// InitWallet = "initWallet"
+
+```
+```typescript
+export interface InitRequest {
+ skipDefaults?: boolean;
+}
+
+```
+```typescript
+export interface InitResponse {
+ versionInfo: WalletCoreVersion;
+}
+
+```
+
+### GetVersionOp
+```typescript
+export type GetVersionOp = {
+ op: WalletApiOperation.GetVersion;
+ request: EmptyObject;
+ response: WalletCoreVersion;
+};
+// GetVersion = "getVersion"
+
+```
+
+### GetBalancesOp
+```typescript
+/**
+ * Get current wallet balance.
+ */
+export type GetBalancesOp = {
+ op: WalletApiOperation.GetBalances;
+ request: EmptyObject;
+ response: BalancesResponse;
+};
+// GetBalances = "getBalances"
+
+```
+```typescript
+export interface BalancesResponse {
+ balances: Balance[];
+}
+
+```
+```typescript
+export interface Balance {
+ scopeInfo: ScopeInfo;
+ available: AmountString;
+ pendingIncoming: AmountString;
+ pendingOutgoing: AmountString;
+ hasPendingTransactions: boolean;
+ requiresUserInput: boolean;
+}
+
+```
+```typescript
+export type ScopeInfo =
+ | {
+ type: ScopeType.Global;
+ currency: string;
+ }
+ | {
+ type: ScopeType.Exchange;
+ currency: string;
+ url: string;
+ }
+ | {
+ type: ScopeType.Auditor;
+ currency: string;
+ url: string;
+ };
+
+```
+
+### GetBalancesDetailOp
+```typescript
+export type GetBalancesDetailOp = {
+ op: WalletApiOperation.GetBalanceDetail;
+ request: GetBalanceDetailRequest;
+ response: MerchantPaymentBalanceDetails;
+};
+// GetBalanceDetail = "getBalanceDetail"
+
+```
+```typescript
+export interface GetBalanceDetailRequest {
+ currency: string;
+}
+
+```
+```typescript
+export interface MerchantPaymentBalanceDetails {
+ /**
+ * Balance of type "available" (see balance.ts for definition).
+ */
+ balanceAvailable: AmountJson;
+ /**
+ * Balance of type "material" (see balance.ts for definition).
+ */
+ balanceMaterial: AmountJson;
+ /**
+ * Balance of type "age-acceptable" (see balance.ts for definition).
+ */
+ balanceAgeAcceptable: AmountJson;
+ /**
+ * Balance of type "merchant-acceptable" (see balance.ts for definition).
+ */
+ balanceMerchantAcceptable: AmountJson;
+ /**
+ * Balance of type "merchant-depositable" (see balance.ts for definition).
+ */
+ balanceMerchantDepositable: AmountJson;
+}
+
+```
+```typescript
+/**
+ * Non-negative financial amount. Fractional values are expressed as multiples
+ * of 1e-8.
+ */
+export interface AmountJson {
+ /**
+ * Value, must be an integer.
+ */
+ readonly value: number;
+ /**
+ * Fraction, must be an integer. Represent 1/1e8 of a unit.
+ */
+ readonly fraction: number;
+ /**
+ * Currency of the amount.
+ */
+ readonly currency: string;
+}
+
+```
+
+### GetTransactionsOp
+```typescript
+/**
+ * Get transactions.
+ */
+export type GetTransactionsOp = {
+ op: WalletApiOperation.GetTransactions;
+ request: TransactionsRequest;
+ response: TransactionsResponse;
+};
+// GetTransactions = "getTransactions"
+
+```
+```typescript
+export interface TransactionsRequest {
+ /**
+ * return only transactions in the given currency
+ */
+ currency?: string;
+ /**
+ * if present, results will be limited to transactions related to the given
search string
+ */
+ search?: string;
+ /**
+ * If true, include all refreshes in the transactions list.
+ */
+ includeRefreshes?: boolean;
+}
+
+```
+```typescript
+export interface TransactionsResponse {
+ transactions: Transaction[];
+}
+
+```
+
+### GetTransactionByIdOp
+```typescript
+export type GetTransactionByIdOp = {
+ op: WalletApiOperation.GetTransactionById;
+ request: TransactionByIdRequest;
+ response: Transaction;
+};
+// GetTransactionById = "getTransactionById"
+
+```
+```typescript
+export interface TransactionByIdRequest {
+ transactionId: string;
+}
+
+```
+
+### RetryPendingNowOp
+```typescript
+export type RetryPendingNowOp = {
+ op: WalletApiOperation.RetryPendingNow;
+ request: EmptyObject;
+ response: EmptyObject;
+};
+// RetryPendingNow = "retryPendingNow"
+
+```
+
+### DeleteTransactionOp
+```typescript
+/**
+ * Delete a transaction locally in the wallet.
+ */
+export type DeleteTransactionOp = {
+ op: WalletApiOperation.DeleteTransaction;
+ request: DeleteTransactionRequest;
+ response: EmptyObject;
+};
+// DeleteTransaction = "deleteTransaction"
+
+```
+```typescript
+export interface DeleteTransactionRequest {
+ transactionId: string;
+}
+
+```
+
+### RetryTransactionOp
+```typescript
+/**
+ * Immediately retry a transaction.
+ */
+export type RetryTransactionOp = {
+ op: WalletApiOperation.RetryTransaction;
+ request: RetryTransactionRequest;
+ response: EmptyObject;
+};
+// RetryTransaction = "retryTransaction"
+
+```
+```typescript
+export interface RetryTransactionRequest {
+ transactionId: string;
+}
+
+```
+
+### AbortTransactionOp
+```typescript
+/**
+ * Abort a transaction
+ *
+ * For payment transactions, it puts the payment into an "aborting" state.
+ */
+export type AbortTransactionOp = {
+ op: WalletApiOperation.AbortTransaction;
+ request: AbortTransactionRequest;
+ response: EmptyObject;
+};
+// AbortTransaction = "abortTransaction"
+
+```
+
+### SuspendTransactionOp
+```typescript
+/**
+ * Suspend a transaction
+ */
+export type SuspendTransactionOp = {
+ op: WalletApiOperation.SuspendTransaction;
+ request: AbortTransactionRequest;
+ response: EmptyObject;
+};
+// SuspendTransaction = "suspendTransaction"
+
+```
+
+### ResumeTransactionOp
+```typescript
+/**
+ * Resume a transaction
+ */
+export type ResumeTransactionOp = {
+ op: WalletApiOperation.ResumeTransaction;
+ request: AbortTransactionRequest;
+ response: EmptyObject;
+};
+// ResumeTransaction = "resumeTransaction"
+
+```
+
+### GetWithdrawalDetailsForAmountOp
+```typescript
+/**
+ * Get details for withdrawing a particular amount (manual withdrawal).
+ */
+export type GetWithdrawalDetailsForAmountOp = {
+ op: WalletApiOperation.GetWithdrawalDetailsForAmount;
+ request: GetWithdrawalDetailsForAmountRequest;
+ response: ManualWithdrawalDetails;
+};
+// GetWithdrawalDetailsForAmount = "getWithdrawalDetailsForAmount"
+
+```
+```typescript
+export interface GetWithdrawalDetailsForAmountRequest {
+ exchangeBaseUrl: string;
+ amount: string;
+ restrictAge?: number;
+}
+
+```
+```typescript
+export interface ManualWithdrawalDetails {
+ /**
+ * Did the user accept the current version of the exchange's
+ * terms of service?
+ */
+ tosAccepted: boolean;
+ /**
+ * Amount that the user will transfer to the exchange.
+ */
+ amountRaw: AmountString;
+ /**
+ * Amount that will be added to the user's wallet balance.
+ */
+ amountEffective: AmountString;
+ /**
+ * Ways to pay the exchange.
+ */
+ paytoUris: string[];
+ /**
+ * If the exchange supports age-restricted coins it will return
+ * the array of ages.
+ */
+ ageRestrictionOptions?: number[];
+}
+
+```
+
+### GetWithdrawalDetailsForUriOp
+```typescript
+/**
+ * Get details for withdrawing via a particular taler:// URI.
+ */
+export type GetWithdrawalDetailsForUriOp = {
+ op: WalletApiOperation.GetWithdrawalDetailsForUri;
+ request: GetWithdrawalDetailsForUriRequest;
+ response: WithdrawUriInfoResponse;
+};
+// GetWithdrawalDetailsForUri = "getWithdrawalDetailsForUri"
+
+```
+```typescript
+export interface GetWithdrawalDetailsForUriRequest {
+ talerWithdrawUri: string;
+ restrictAge?: number;
+}
+
+```
+```typescript
+export interface WithdrawUriInfoResponse {
+ amount: AmountString;
+ defaultExchangeBaseUrl?: string;
+ possibleExchanges: ExchangeListItem[];
+}
+
+```
+
+### AcceptBankIntegratedWithdrawalOp
+```typescript
+/**
+ * Accept a bank-integrated withdrawal.
+ */
+export type AcceptBankIntegratedWithdrawalOp = {
+ op: WalletApiOperation.AcceptBankIntegratedWithdrawal;
+ request: AcceptBankIntegratedWithdrawalRequest;
+ response: AcceptWithdrawalResponse;
+};
+// AcceptBankIntegratedWithdrawal = "acceptBankIntegratedWithdrawal"
+
+```
+```typescript
+export interface AcceptBankIntegratedWithdrawalRequest {
+ talerWithdrawUri: string;
+ exchangeBaseUrl: string;
+ forcedDenomSel?: ForcedDenomSel;
+ restrictAge?: number;
+}
+
+```
+```typescript
+export interface AcceptWithdrawalResponse {
+ reservePub: string;
+ confirmTransferUrl?: string;
+ transactionId: string;
+}
+
+```
+
+### AcceptManualWithdrawalOp
+```typescript
+/**
+ * Create a manual withdrawal.
+ */
+export type AcceptManualWithdrawalOp = {
+ op: WalletApiOperation.AcceptManualWithdrawal;
+ request: AcceptManualWithdrawalRequest;
+ response: AcceptManualWithdrawalResult;
+};
+// AcceptManualWithdrawal = "acceptManualWithdrawal"
+
+```
+```typescript
+export interface AcceptManualWithdrawalRequest {
+ exchangeBaseUrl: string;
+ amount: string;
+ restrictAge?: number;
+}
+
+```
+```typescript
+export interface AcceptManualWithdrawalResult {
+ /**
+ * Payto URIs that can be used to fund the withdrawal.
+ */
+ exchangePaytoUris: string[];
+ /**
+ * Public key of the newly created reserve.
+ */
+ reservePub: string;
+ transactionId: string;
+}
+
+```
+
+### PreparePayForUriOp
+```typescript
+/**
+ * Prepare to make a payment based on a taler://pay/ URI.
+ */
+export type PreparePayForUriOp = {
+ op: WalletApiOperation.PreparePayForUri;
+ request: PreparePayRequest;
+ response: PreparePayResult;
+};
+// PreparePayForUri = "preparePayForUri"
+
+```
+```typescript
+export interface PreparePayRequest {
+ talerPayUri: string;
+}
+
+```
+
+### PreparePayForTemplateOp
+```typescript
+/**
+ * Prepare to make a payment based on a taler://pay-template/ URI.
+ */
+export type PreparePayForTemplateOp = {
+ op: WalletApiOperation.PreparePayForTemplate;
+ request: PreparePayTemplateRequest;
+ response: PreparePayResult;
+};
+// PreparePayForTemplate = "preparePayForTemplate"
+
+```
+```typescript
+export interface PreparePayTemplateRequest {
+ talerPayTemplateUri: string;
+ templateParams: Record<string, string>;
+}
+
+```
+
+### GetContractTermsDetailsOp
+```typescript
+export type GetContractTermsDetailsOp = {
+ op: WalletApiOperation.GetContractTermsDetails;
+ request: GetContractTermsDetailsRequest;
+ response: WalletContractData;
+};
+// GetContractTermsDetails = "getContractTermsDetails"
+
+```
+```typescript
+export interface GetContractTermsDetailsRequest {
+ proposalId: string;
+}
+
+```
+```typescript
+/**
+ * Data extracted from the contract terms that is relevant for payment
+ * processing in the wallet.
+ */
+export interface WalletContractData {
+ products?: Product[];
+ summaryI18n:
+ | {
+ [lang_tag: string]: string;
+ }
+ | undefined;
+ /**
+ * Fulfillment URL, or the empty string if the order has no fulfillment URL.
+ *
+ * Stored as a non-nullable string as we use this field for IndexedDB
indexing.
+ */
+ fulfillmentUrl: string;
+ contractTermsHash: string;
+ fulfillmentMessage?: string;
+ fulfillmentMessageI18n?: InternationalizedString;
+ merchantSig: string;
+ merchantPub: string;
+ merchant: MerchantInfo;
+ amount: AmountString;
+ orderId: string;
+ merchantBaseUrl: string;
+ summary: string;
+ autoRefund: TalerProtocolDuration | undefined;
+ maxWireFee: AmountString;
+ wireFeeAmortization: number;
+ payDeadline: TalerProtocolTimestamp;
+ refundDeadline: TalerProtocolTimestamp;
+ allowedAuditors: AllowedAuditorInfo[];
+ allowedExchanges: AllowedExchangeInfo[];
+ timestamp: TalerProtocolTimestamp;
+ wireMethod: string;
+ wireInfoHash: string;
+ maxDepositFee: AmountString;
+ minimumAge?: number;
+ deliveryDate: TalerProtocolTimestamp | undefined;
+ deliveryLocation: Location | undefined;
+}
+
+```
+```typescript
+export interface AllowedAuditorInfo {
+ auditorBaseUrl: string;
+ auditorPub: string;
+}
+
+```
+```typescript
+export interface AllowedExchangeInfo {
+ exchangeBaseUrl: string;
+ exchangePub: string;
+}
+
+```
+
+### ConfirmPayOp
+```typescript
+/**
+ * Confirm a payment that was previously prepared with
+ * {@link PreparePayForUriOp}
+ */
+export type ConfirmPayOp = {
+ op: WalletApiOperation.ConfirmPay;
+ request: ConfirmPayRequest;
+ response: ConfirmPayResult;
+};
+// ConfirmPay = "confirmPay"
+
+```
+```typescript
+export interface ConfirmPayRequest {
+ proposalId: string;
+ sessionId?: string;
+ forcedCoinSel?: ForcedCoinSel;
+}
+
+```
+```typescript
+export type ConfirmPayResult = ConfirmPayResultDone | ConfirmPayResultPending;
+
+```
+```typescript
+/**
+ * Result for confirmPay
+ */
+export interface ConfirmPayResultDone {
+ type: ConfirmPayResultType.Done;
+ contractTerms: MerchantContractTerms;
+ transactionId: string;
+}
+
+```
+```typescript
+export interface ConfirmPayResultPending {
+ type: ConfirmPayResultType.Pending;
+ transactionId: string;
+ lastError: TalerErrorDetail | undefined;
+}
+
+```
+
+### ApplyRefundOp
+```typescript
+/**
+ * Check for a refund based on a taler://refund URI.
+ */
+export type ApplyRefundOp = {
+ op: WalletApiOperation.ApplyRefund;
+ request: ApplyRefundRequest;
+ response: ApplyRefundResponse;
+};
+// ApplyRefund = "applyRefund"
+
+```
+```typescript
+export interface ApplyRefundRequest {
+ talerRefundUri: string;
+}
+
+```
+
+### ApplyRefundFromPurchaseIdOp
+```typescript
+export type ApplyRefundFromPurchaseIdOp = {
+ op: WalletApiOperation.ApplyRefundFromPurchaseId;
+ request: ApplyRefundFromPurchaseIdRequest;
+ response: ApplyRefundResponse;
+};
+// ApplyRefundFromPurchaseId = "applyRefundFromPurchaseId"
+
+```
+```typescript
+export interface ApplyRefundFromPurchaseIdRequest {
+ purchaseId: string;
+}
+
+```
+
+### PrepareRefundOp
+```typescript
+export type PrepareRefundOp = {
+ op: WalletApiOperation.PrepareRefund;
+ request: PrepareRefundRequest;
+ response: PrepareRefundResult;
+};
+// PrepareRefund = "prepareRefund"
+
+```
+```typescript
+export interface PrepareRefundRequest {
+ talerRefundUri: string;
+}
+
+```
+```typescript
+export interface PrepareRefundResult {
+ proposalId: string;
+ effectivePaid: AmountString;
+ gone: AmountString;
+ granted: AmountString;
+ pending: boolean;
+ awaiting: AmountString;
+ info: OrderShortInfo;
+}
+
+```
+
+### PrepareTipOp
+```typescript
+/**
+ * Query and store information about a tip.
+ */
+export type PrepareTipOp = {
+ op: WalletApiOperation.PrepareTip;
+ request: PrepareTipRequest;
+ response: PrepareTipResult;
+};
+// PrepareTip = "prepareTip"
+
+```
+```typescript
+export interface PrepareTipRequest {
+ talerTipUri: string;
+}
+
+```
+```typescript
+export interface PrepareTipResult {
+ /**
+ * Unique ID for the tip assigned by the wallet.
+ * Typically different from the merchant-generated tip ID.
+ */
+ walletTipId: string;
+ /**
+ * Has the tip already been accepted?
+ */
+ accepted: boolean;
+ /**
+ * Amount that the merchant gave.
+ */
+ tipAmountRaw: AmountString;
+ /**
+ * Amount that arrived at the wallet.
+ * Might be lower than the raw amount due to fees.
+ */
+ tipAmountEffective: AmountString;
+ /**
+ * Base URL of the merchant backend giving then tip.
+ */
+ merchantBaseUrl: string;
+ /**
+ * Base URL of the exchange that is used to withdraw the tip.
+ * Determined by the merchant, the wallet/user has no choice here.
+ */
+ exchangeBaseUrl: string;
+ /**
+ * Time when the tip will expire. After it expired, it can't be picked
+ * up anymore.
+ */
+ expirationTimestamp: TalerProtocolTimestamp;
+}
+
+```
+
+### AcceptTipOp
+```typescript
+/**
+ * Accept a tip.
+ */
+export type AcceptTipOp = {
+ op: WalletApiOperation.AcceptTip;
+ request: AcceptTipRequest;
+ response: AcceptTipResponse;
+};
+// AcceptTip = "acceptTip"
+
+```
+```typescript
+export interface AcceptTipRequest {
+ walletTipId: string;
+}
+
+```
+```typescript
+export interface AcceptTipResponse {
+ transactionId: string;
+ next_url?: string;
+}
+
+```
+
+### ListExchangesOp
+```typescript
+/**
+ * List exchanges known to the wallet.
+ */
+export type ListExchangesOp = {
+ op: WalletApiOperation.ListExchanges;
+ request: EmptyObject;
+ response: ExchangesListResponse;
+};
+// ListExchanges = "listExchanges"
+
+```
+```typescript
+export interface ExchangesListResponse {
+ exchanges: ExchangeListItem[];
+}
+
+```
+
+### AddExchangeOp
+```typescript
+/**
+ * Add / force-update an exchange.
+ */
+export type AddExchangeOp = {
+ op: WalletApiOperation.AddExchange;
+ request: AddExchangeRequest;
+ response: EmptyObject;
+};
+// AddExchange = "addExchange"
+
+```
+
+### ListKnownBankAccountsOp
+```typescript
+export type ListKnownBankAccountsOp = {
+ op: WalletApiOperation.ListKnownBankAccounts;
+ request: ListKnownBankAccountsRequest;
+ response: KnownBankAccounts;
+};
+// ListKnownBankAccounts = "listKnownBankAccounts"
+
+```
+```typescript
+export interface ListKnownBankAccountsRequest {
+ currency?: string;
+}
+
+```
+```typescript
+export interface KnownBankAccounts {
+ accounts: KnownBankAccountsInfo[];
+}
+
+```
+```typescript
+export interface KnownBankAccountsInfo {
+ uri: PaytoUri;
+ kyc_completed: boolean;
+ currency: string;
+ alias: string;
+}
+
+```
+```typescript
+export type PaytoUri =
+ | PaytoUriUnknown
+ | PaytoUriIBAN
+ | PaytoUriTalerBank
+ | PaytoUriBitcoin;
+
+```
+```typescript
+export interface PaytoUriUnknown extends PaytoUriGeneric {
+ isKnown: false;
+}
+
+```
+```typescript
+export interface PaytoUriGeneric {
+ targetType: string;
+ targetPath: string;
+ params: {
+ [name: string]: string;
+ };
+}
+
+```
+```typescript
+export interface PaytoUriIBAN extends PaytoUriGeneric {
+ isKnown: true;
+ targetType: "iban";
+ iban: string;
+ bic?: string;
+}
+
+```
+```typescript
+export interface PaytoUriTalerBank extends PaytoUriGeneric {
+ isKnown: true;
+ targetType: "x-taler-bank";
+ host: string;
+ account: string;
+}
+
+```
+```typescript
+export interface PaytoUriBitcoin extends PaytoUriGeneric {
+ isKnown: true;
+ targetType: "bitcoin";
+ segwitAddrs: Array<string>;
+}
+
+```
+
+### AddKnownBankAccountsOp
+```typescript
+export type AddKnownBankAccountsOp = {
+ op: WalletApiOperation.AddKnownBankAccounts;
+ request: AddKnownBankAccountsRequest;
+ response: EmptyObject;
+};
+// AddKnownBankAccounts = "addKnownBankAccounts"
+
+```
+```typescript
+export interface AddKnownBankAccountsRequest {
+ payto: string;
+ alias: string;
+ currency: string;
+}
+
+```
+
+### ForgetKnownBankAccountsOp
+```typescript
+export type ForgetKnownBankAccountsOp = {
+ op: WalletApiOperation.ForgetKnownBankAccounts;
+ request: ForgetKnownBankAccountsRequest;
+ response: EmptyObject;
+};
+// ForgetKnownBankAccounts = "forgetKnownBankAccounts"
+
+```
+```typescript
+export interface ForgetKnownBankAccountsRequest {
+ payto: string;
+}
+
+```
+
+### SetExchangeTosAcceptedOp
+```typescript
+/**
+ * Accept a particular version of the exchange terms of service.
+ */
+export type SetExchangeTosAcceptedOp = {
+ op: WalletApiOperation.SetExchangeTosAccepted;
+ request: AcceptExchangeTosRequest;
+ response: EmptyObject;
+};
+// SetExchangeTosAccepted = "setExchangeTosAccepted"
+
+```
+```typescript
+export interface AcceptExchangeTosRequest {
+ exchangeBaseUrl: string;
+ etag: string | undefined;
+}
+
+```
+
+### GetExchangeTosOp
+```typescript
+/**
+ * Get the current terms of a service of an exchange.
+ */
+export type GetExchangeTosOp = {
+ op: WalletApiOperation.GetExchangeTos;
+ request: GetExchangeTosRequest;
+ response: GetExchangeTosResult;
+};
+// GetExchangeTos = "getExchangeTos"
+
+```
+```typescript
+export interface GetExchangeTosRequest {
+ exchangeBaseUrl: string;
+ acceptedFormat?: string[];
+}
+
+```
+```typescript
+export interface GetExchangeTosResult {
+ /**
+ * Markdown version of the current ToS.
+ */
+ content: string;
+ /**
+ * Version tag of the current ToS.
+ */
+ currentEtag: string;
+ /**
+ * Version tag of the last ToS that the user has accepted,
+ * if any.
+ */
+ acceptedEtag: string | undefined;
+ /**
+ * Accepted content type
+ */
+ contentType: string;
+ tosStatus: ExchangeTosStatus;
+}
+
+```
+
+### GetExchangeDetailedInfoOp
+```typescript
+/**
+ * Get the current terms of a service of an exchange.
+ */
+export type GetExchangeDetailedInfoOp = {
+ op: WalletApiOperation.GetExchangeDetailedInfo;
+ request: AddExchangeRequest;
+ response: ExchangeDetailedResponse;
+};
+// GetExchangeDetailedInfo = "getExchangeDetailedInfo"
+
+```
+```typescript
+export interface ExchangeDetailedResponse {
+ exchange: ExchangeFullDetails;
+}
+
+```
+```typescript
+export interface ExchangeFullDetails {
+ exchangeBaseUrl: string;
+ currency: string;
+ paytoUris: string[];
+ tos: ExchangeTosStatusDetails;
+ auditors: ExchangeAuditor[];
+ wireInfo: WireInfo;
+ denomFees: DenomOperationMap<FeeDescription[]>;
+ transferFees: Record<string, FeeDescription[]>;
+ globalFees: FeeDescription[];
+}
+
+```
+```typescript
+export interface ExchangeTosStatusDetails {
+ acceptedVersion?: string;
+ currentVersion?: string;
+ contentType?: string;
+ content?: string;
+}
+
+```
+```typescript
+export interface WireInfo {
+ feesForType: WireFeeMap;
+ accounts: ExchangeAccount[];
+}
+
+```
+```typescript
+/**
+ * Information about one of the exchange's bank accounts.
+ */
+export interface ExchangeAccount {
+ payto_uri: string;
+ master_sig: string;
+}
+
+```
+```typescript
+export interface FeeDescription {
+ group: string;
+ from: AbsoluteTime;
+ until: AbsoluteTime;
+ fee?: AmountString;
+}
+
+```
+
+### ListCurrenciesOp
+```typescript
+/**
+ * List currencies known to the wallet.
+ */
+export type ListCurrenciesOp = {
+ op: WalletApiOperation.ListCurrencies;
+ request: EmptyObject;
+ response: WalletCurrencyInfo;
+};
+// ListCurrencies = "listCurrencies"
+
+```
+```typescript
+export interface WalletCurrencyInfo {
+ trustedAuditors: {
+ currency: string;
+ auditorPub: string;
+ auditorBaseUrl: string;
+ }[];
+ trustedExchanges: {
+ currency: string;
+ exchangeMasterPub: string;
+ exchangeBaseUrl: string;
+ }[];
+}
+
+```
+
+### GenerateDepositGroupTxIdOp
+```typescript
+/**
+ * Generate a fresh transaction ID for a deposit group.
+ *
+ * The resulting transaction ID can be specified when creating
+ * a deposit group, so that the client can already start waiting for
notifications
+ * on that specific deposit group before the GreateDepositGroup request
returns.
+ */
+export type GenerateDepositGroupTxIdOp = {
+ op: WalletApiOperation.GenerateDepositGroupTxId;
+ request: EmptyObject;
+ response: TxIdResponse;
+};
+// GenerateDepositGroupTxId = "generateDepositGroupTxId"
+
+```
+```typescript
+export interface TxIdResponse {
+ transactionId: string;
+}
+
+```
+
+### CreateDepositGroupOp
+```typescript
+/**
+ * Create a new deposit group.
+ *
+ * Deposit groups are used to deposit multiple coins to a bank
+ * account, usually the wallet user's own bank account.
+ */
+export type CreateDepositGroupOp = {
+ op: WalletApiOperation.CreateDepositGroup;
+ request: CreateDepositGroupRequest;
+ response: CreateDepositGroupResponse;
+};
+// CreateDepositGroup = "createDepositGroup"
+
+```
+```typescript
+export interface CreateDepositGroupRequest {
+ /**
+ * Pre-allocated transaction ID.
+ * Allows clients to easily handle notifications
+ * that occur while the operation has been created but
+ * before the creation request has returned.
+ */
+ transactionId?: string;
+ depositPaytoUri: string;
+ amount: AmountString;
+}
+
+```
+```typescript
+export interface CreateDepositGroupResponse {
+ depositGroupId: string;
+ transactionId: string;
+}
+
+```
+
+### PrepareDepositOp
+```typescript
+export type PrepareDepositOp = {
+ op: WalletApiOperation.PrepareDeposit;
+ request: PrepareDepositRequest;
+ response: PrepareDepositResponse;
+};
+// PrepareDeposit = "prepareDeposit"
+
+```
+```typescript
+export interface PrepareDepositRequest {
+ depositPaytoUri: string;
+ amount: AmountString;
+}
+
+```
+```typescript
+export interface PrepareDepositResponse {
+ totalDepositCost: AmountString;
+ effectiveDepositAmount: AmountString;
+ fees: DepositGroupFees;
+}
+
+```
+```typescript
+export interface DepositGroupFees {
+ coin: AmountString;
+ wire: AmountString;
+ refresh: AmountString;
+}
+
+```
+
+### ExportBackupRecoveryOp
+```typescript
+/**
+ * Export the recovery information for the wallet.
+ */
+export type ExportBackupRecoveryOp = {
+ op: WalletApiOperation.ExportBackupRecovery;
+ request: EmptyObject;
+ response: BackupRecovery;
+};
+// ExportBackupRecovery = "exportBackupRecovery"
+
+```
+
+### ImportBackupRecoveryOp
+```typescript
+/**
+ * Import recovery information into the wallet.
+ */
+export type ImportBackupRecoveryOp = {
+ op: WalletApiOperation.ImportBackupRecovery;
+ request: RecoveryLoadRequest;
+ response: EmptyObject;
+};
+// ImportBackupRecovery = "importBackupRecovery"
+
+```
+```typescript
+/**
+ * Load recovery information into the wallet.
+ */
+export interface RecoveryLoadRequest {
+ recovery: BackupRecovery;
+ strategy?: RecoveryMergeStrategy;
+}
+
+```
+```typescript
+/**
+ * Strategy for loading recovery information.
+ */
+export declare enum RecoveryMergeStrategy {
+ /**
+ * Keep the local wallet root key, import and take over providers.
+ */
+ Ours = "ours",
+ /**
+ * Migrate to the wallet root key from the recovery information.
+ */
+ Theirs = "theirs",
+}
+
+```
+
+### RunBackupCycleOp
+```typescript
+/**
+ * Manually make and upload a backup.
+ */
+export type RunBackupCycleOp = {
+ op: WalletApiOperation.RunBackupCycle;
+ request: RunBackupCycleRequest;
+ response: EmptyObject;
+};
+// RunBackupCycle = "runBackupCycle"
+
+```
+```typescript
+export interface RunBackupCycleRequest {
+ /**
+ * List of providers to backup or empty for all known providers.
+ */
+ providers?: Array<string>;
+}
+
+```
+
+### ExportBackupOp
+```typescript
+export type ExportBackupOp = {
+ op: WalletApiOperation.ExportBackup;
+ request: EmptyObject;
+ response: EmptyObject;
+};
+// ExportBackup = "exportBackup"
+
+```
+
+### AddBackupProviderOp
+```typescript
+/**
+ * Add a new backup provider.
+ */
+export type AddBackupProviderOp = {
+ op: WalletApiOperation.AddBackupProvider;
+ request: AddBackupProviderRequest;
+ response: AddBackupProviderResponse;
+};
+// AddBackupProvider = "addBackupProvider"
+
+```
+```typescript
+export interface AddBackupProviderRequest {
+ backupProviderBaseUrl: string;
+ name: string;
+ /**
+ * Activate the provider. Should only be done after
+ * the user has reviewed the provider.
+ */
+ activate?: boolean;
+}
+
+```
+```typescript
+export type AddBackupProviderResponse =
+ | AddBackupProviderOk
+ | AddBackupProviderPaymentRequired;
+
+```
+```typescript
+interface AddBackupProviderOk {
+ status: "ok";
+}
+
+```
+```typescript
+interface AddBackupProviderPaymentRequired {
+ status: "payment-required";
+ talerUri?: string;
+}
+
+```
+
+### RemoveBackupProviderOp
+```typescript
+export type RemoveBackupProviderOp = {
+ op: WalletApiOperation.RemoveBackupProvider;
+ request: RemoveBackupProviderRequest;
+ response: EmptyObject;
+};
+// RemoveBackupProvider = "removeBackupProvider"
+
+```
+```typescript
+export interface RemoveBackupProviderRequest {
+ provider: string;
+}
+
+```
+
+### GetBackupInfoOp
+```typescript
+/**
+ * Get some useful stats about the backup state.
+ */
+export type GetBackupInfoOp = {
+ op: WalletApiOperation.GetBackupInfo;
+ request: EmptyObject;
+ response: BackupInfo;
+};
+// GetBackupInfo = "getBackupInfo"
+
+```
+```typescript
+export interface BackupInfo {
+ walletRootPub: string;
+ deviceId: string;
+ providers: ProviderInfo[];
+}
+
+```
+```typescript
+/**
+ * Information about one provider.
+ *
+ * We don't store the account key here,
+ * as that's derived from the wallet root key.
+ */
+export interface ProviderInfo {
+ active: boolean;
+ syncProviderBaseUrl: string;
+ name: string;
+ terms?: BackupProviderTerms;
+ /**
+ * Last communication issue with the provider.
+ */
+ lastError?: TalerErrorDetail;
+ lastSuccessfulBackupTimestamp?: TalerProtocolTimestamp;
+ lastAttemptedBackupTimestamp?: TalerProtocolTimestamp;
+ paymentProposalIds: string[];
+ backupProblem?: BackupProblem;
+ paymentStatus: ProviderPaymentStatus;
+}
+
+```
+```typescript
+export interface BackupProviderTerms {
+ supportedProtocolVersion: string;
+ annualFee: AmountString;
+ storageLimitInMegabytes: number;
+}
+
+```
+```typescript
+export type BackupProblem =
+ | BackupUnreadableProblem
+ | BackupConflictingDeviceProblem;
+
+```
+```typescript
+export interface BackupUnreadableProblem {
+ type: "backup-unreadable";
+}
+
+```
+```typescript
+export interface BackupConflictingDeviceProblem {
+ type: "backup-conflicting-device";
+ otherDeviceId: string;
+ myDeviceId: string;
+ backupTimestamp: AbsoluteTime;
+}
+
+```
+```typescript
+export type ProviderPaymentStatus =
+ | ProviderPaymentTermsChanged
+ | ProviderPaymentPaid
+ | ProviderPaymentInsufficientBalance
+ | ProviderPaymentUnpaid
+ | ProviderPaymentPending;
+
+```
+```typescript
+export interface ProviderPaymentTermsChanged {
+ type: ProviderPaymentType.TermsChanged;
+ paidUntil: AbsoluteTime;
+ oldTerms: BackupProviderTerms;
+ newTerms: BackupProviderTerms;
+}
+
+```
+```typescript
+export interface ProviderPaymentPaid {
+ type: ProviderPaymentType.Paid;
+ paidUntil: AbsoluteTime;
+}
+
+```
+```typescript
+export interface ProviderPaymentInsufficientBalance {
+ type: ProviderPaymentType.InsufficientBalance;
+ amount: AmountString;
+}
+
+```
+```typescript
+export interface ProviderPaymentUnpaid {
+ type: ProviderPaymentType.Unpaid;
+}
+
+```
+```typescript
+export interface ProviderPaymentPending {
+ type: ProviderPaymentType.Pending;
+ talerUri?: string;
+}
+
+```
+
+### SetWalletDeviceIdOp
+```typescript
+/**
+ * Set the internal device ID of the wallet, used to
+ * identify whether a different/new wallet is accessing
+ * the backup of another wallet.
+ */
+export type SetWalletDeviceIdOp = {
+ op: WalletApiOperation.SetWalletDeviceId;
+ request: SetWalletDeviceIdRequest;
+ response: EmptyObject;
+};
+// SetWalletDeviceId = "setWalletDeviceId"
+
+```
+```typescript
+export interface SetWalletDeviceIdRequest {
+ /**
+ * New wallet device ID to set.
+ */
+ walletDeviceId: string;
+}
+
+```
+
+### ExportBackupPlainOp
+```typescript
+/**
+ * Export a backup JSON, mostly useful for testing.
+ */
+export type ExportBackupPlainOp = {
+ op: WalletApiOperation.ExportBackupPlain;
+ request: EmptyObject;
+ response: WalletBackupContentV1;
+};
+// ExportBackupPlain = "exportBackupPlain"
+
+```
+
+### CheckPeerPushDebitOp
+```typescript
+/**
+ * Check if initiating a peer push payment is possible
+ * based on the funds in the wallet.
+ */
+export type CheckPeerPushDebitOp = {
+ op: WalletApiOperation.CheckPeerPushDebit;
+ request: CheckPeerPushDebitRequest;
+ response: CheckPeerPushDebitResponse;
+};
+// CheckPeerPushDebit = "checkPeerPushDebit"
+
+```
+```typescript
+export interface CheckPeerPushDebitRequest {
+ /**
+ * Preferred exchange to use for the p2p payment.
+ */
+ exchangeBaseUrl?: string;
+ /**
+ * Instructed amount.
+ *
+ * FIXME: Allow specifying the instructed amount type.
+ */
+ amount: AmountString;
+}
+
+```
+```typescript
+export interface CheckPeerPushDebitResponse {
+ amountRaw: AmountString;
+ amountEffective: AmountString;
+}
+
+```
+
+### InitiatePeerPushDebitOp
+```typescript
+/**
+ * Initiate an outgoing peer push payment.
+ */
+export type InitiatePeerPushDebitOp = {
+ op: WalletApiOperation.InitiatePeerPushDebit;
+ request: InitiatePeerPushPaymentRequest;
+ response: InitiatePeerPushPaymentResponse;
+};
+// InitiatePeerPushDebit = "initiatePeerPushDebit"
+
+```
+```typescript
+export interface InitiatePeerPushPaymentRequest {
+ exchangeBaseUrl?: string;
+ partialContractTerms: PeerContractTerms;
+}
+
+```
+```typescript
+export interface InitiatePeerPushPaymentResponse {
+ exchangeBaseUrl: string;
+ pursePub: string;
+ mergePriv: string;
+ contractPriv: string;
+ talerUri: string;
+ transactionId: string;
+}
+
+```
+
+### PreparePeerPushCreditOp
+```typescript
+/**
+ * Check an incoming peer push payment.
+ */
+export type PreparePeerPushCreditOp = {
+ op: WalletApiOperation.PreparePeerPushCredit;
+ request: PreparePeerPushCredit;
+ response: PreparePeerPushCreditResponse;
+};
+// PreparePeerPushCredit = "preparePeerPushCredit"
+
+```
+```typescript
+export interface PreparePeerPushCreditResponse {
+ contractTerms: PeerContractTerms;
+ /**
+ * @deprecated
+ */
+ amount: AmountString;
+ amountRaw: AmountString;
+ amountEffective: AmountString;
+ peerPushPaymentIncomingId: string;
+}
+
+```
+
+### ConfirmPeerPushCreditOp
+```typescript
+/**
+ * Accept an incoming peer push payment.
+ */
+export type ConfirmPeerPushCreditOp = {
+ op: WalletApiOperation.ConfirmPeerPushCredit;
+ request: ConfirmPeerPushCreditRequest;
+ response: EmptyObject;
+};
+// ConfirmPeerPushCredit = "confirmPeerPushCredit"
+
+```
+```typescript
+export interface ConfirmPeerPushCreditRequest {
+ /**
+ * Transparent identifier of the incoming peer push payment.
+ */
+ peerPushPaymentIncomingId: string;
+}
+
+```
+
+### CheckPeerPullCreditOp
+```typescript
+/**
+ * Check fees for an outgoing peer pull payment.
+ */
+export type CheckPeerPullCreditOp = {
+ op: WalletApiOperation.CheckPeerPullCredit;
+ request: CheckPeerPullCreditRequest;
+ response: CheckPeerPullCreditResponse;
+};
+// CheckPeerPullCredit = "checkPeerPullCredit"
+
+```
+```typescript
+export interface CheckPeerPullCreditRequest {
+ exchangeBaseUrl?: string;
+ amount: AmountString;
+}
+
+```
+```typescript
+export interface CheckPeerPullCreditResponse {
+ exchangeBaseUrl: string;
+ amountRaw: AmountString;
+ amountEffective: AmountString;
+}
+
+```
+
+### InitiatePeerPullCreditOp
+```typescript
+/**
+ * Initiate an outgoing peer pull payment.
+ */
+export type InitiatePeerPullCreditOp = {
+ op: WalletApiOperation.InitiatePeerPullCredit;
+ request: InitiatePeerPullCreditRequest;
+ response: InitiatePeerPullCreditResponse;
+};
+// InitiatePeerPullCredit = "initiatePeerPullCredit"
+
+```
+```typescript
+export interface InitiatePeerPullCreditRequest {
+ exchangeBaseUrl?: string;
+ partialContractTerms: PeerContractTerms;
+}
+
+```
+```typescript
+export interface InitiatePeerPullCreditResponse {
+ /**
+ * Taler URI for the other party to make the payment
+ * that was requested.
+ */
+ talerUri: string;
+ transactionId: string;
+}
+
+```
+
+### PreparePeerPullDebitOp
+```typescript
+/**
+ * Prepare for an incoming peer pull payment.
+ */
+export type PreparePeerPullDebitOp = {
+ op: WalletApiOperation.PreparePeerPullDebit;
+ request: PreparePeerPullDebitRequest;
+ response: PreparePeerPullDebitResponse;
+};
+// PreparePeerPullDebit = "preparePeerPullDebit"
+
+```
+```typescript
+export interface PreparePeerPullDebitRequest {
+ talerUri: string;
+}
+
+```
+```typescript
+export interface PreparePeerPullDebitResponse {
+ contractTerms: PeerContractTerms;
+ /**
+ * @deprecated Redundant field with bad name, will be removed soon.
+ */
+ amount: AmountString;
+ amountRaw: AmountString;
+ amountEffective: AmountString;
+ peerPullPaymentIncomingId: string;
+}
+
+```
+
+### ConfirmPeerPullDebitOp
+```typescript
+/**
+ * Accept an incoming peer pull payment (i.e. pay the other party).
+ */
+export type ConfirmPeerPullDebitOp = {
+ op: WalletApiOperation.ConfirmPeerPullDebit;
+ request: ConfirmPeerPullDebitRequest;
+ response: EmptyObject;
+};
+// ConfirmPeerPullDebit = "confirmPeerPullDebit"
+
+```
+```typescript
+export interface ConfirmPeerPullDebitRequest {
+ /**
+ * Transparent identifier of the incoming peer pull payment.
+ */
+ peerPullPaymentIncomingId: string;
+}
+
+```
+
+### ValidateIbanOp
+```typescript
+export type ValidateIbanOp = {
+ op: WalletApiOperation.ValidateIban;
+ request: ValidateIbanRequest;
+ response: ValidateIbanResponse;
+};
+// ValidateIban = "validateIban"
+
+```
+```typescript
+export interface ValidateIbanRequest {
+ iban: string;
+}
+
+```
+```typescript
+export interface ValidateIbanResponse {
+ valid: boolean;
+}
+
+```
+
+### ExportDbOp
+```typescript
+/**
+ * Export the wallet database's contents to JSON.
+ */
+export type ExportDbOp = {
+ op: WalletApiOperation.ExportDb;
+ request: EmptyObject;
+ response: any;
+};
+// ExportDb = "exportDb"
+
+```
+
+### ImportDbOp
+```typescript
+export type ImportDbOp = {
+ op: WalletApiOperation.ImportDb;
+ request: any;
+ response: any;
+};
+// ImportDb = "importDb"
+
+```
+
+### ClearDbOp
+```typescript
+/**
+ * Dangerously clear the whole wallet database.
+ */
+export type ClearDbOp = {
+ op: WalletApiOperation.ClearDb;
+ request: EmptyObject;
+ response: EmptyObject;
+};
+// ClearDb = "clearDb"
+
+```
+
+### RecycleOp
+```typescript
+/**
+ * Export a backup, clear the database and re-import it.
+ */
+export type RecycleOp = {
+ op: WalletApiOperation.Recycle;
+ request: EmptyObject;
+ response: EmptyObject;
+};
+// Recycle = "recycle"
+
+```
+
+### ApplyDevExperimentOp
+```typescript
+/**
+ * Apply a developer experiment to the current wallet state.
+ *
+ * This allows UI developers / testers to play around without
+ * an elaborate test environment.
+ */
+export type ApplyDevExperimentOp = {
+ op: WalletApiOperation.ApplyDevExperiment;
+ request: ApplyDevExperimentRequest;
+ response: EmptyObject;
+};
+// ApplyDevExperiment = "applyDevExperiment"
+
+```
+```typescript
+export interface ApplyDevExperimentRequest {
+ devExperimentUri: string;
+}
+
+```
+
+### RunIntegrationTestOp
+```typescript
+/**
+ * Run a simple integration test on a test deployment
+ * of the exchange and merchant.
+ */
+export type RunIntegrationTestOp = {
+ op: WalletApiOperation.RunIntegrationTest;
+ request: IntegrationTestArgs;
+ response: EmptyObject;
+};
+// RunIntegrationTest = "runIntegrationTest"
+
+```
+
+### RunIntegrationTestV2Op
+```typescript
+/**
+ * Run a simple integration test on a test deployment
+ * of the exchange and merchant.
+ */
+export type RunIntegrationTestV2Op = {
+ op: WalletApiOperation.RunIntegrationTestV2;
+ request: IntegrationTestArgs;
+ response: EmptyObject;
+};
+// RunIntegrationTestV2 = "runIntegrationTestV2"
+
+```
+
+### TestCryptoOp
+```typescript
+/**
+ * Test crypto worker.
+ */
+export type TestCryptoOp = {
+ op: WalletApiOperation.TestCrypto;
+ request: EmptyObject;
+ response: any;
+};
+// TestCrypto = "testCrypto"
+
+```
+
+### WithdrawTestBalanceOp
+```typescript
+/**
+ * Make withdrawal on a test deployment of the exchange
+ * and merchant.
+ */
+export type WithdrawTestBalanceOp = {
+ op: WalletApiOperation.WithdrawTestBalance;
+ request: WithdrawTestBalanceRequest;
+ response: EmptyObject;
+};
+// WithdrawTestBalance = "withdrawTestBalance"
+
+```
+```typescript
+export interface WithdrawTestBalanceRequest {
+ amount: string;
+ /**
+ * Bank access API base URL.
+ */
+ bankAccessApiBaseUrl: string;
+ exchangeBaseUrl: string;
+ forcedDenomSel?: ForcedDenomSel;
+}
+
+```
+
+### WithdrawTestkudosOp
+```typescript
+/**
+ * Make a withdrawal of testkudos on test.taler.net.
+ */
+export type WithdrawTestkudosOp = {
+ op: WalletApiOperation.WithdrawTestkudos;
+ request: EmptyObject;
+ response: EmptyObject;
+};
+// WithdrawTestkudos = "withdrawTestkudos"
+
+```
+
+### TestPayOp
+```typescript
+/**
+ * Make a test payment using a test deployment of
+ * the exchange and merchant.
+ */
+export type TestPayOp = {
+ op: WalletApiOperation.TestPay;
+ request: TestPayArgs;
+ response: TestPayResult;
+};
+// TestPay = "testPay"
+
+```
+```typescript
+export interface TestPayArgs {
+ merchantBaseUrl: string;
+ merchantAuthToken?: string;
+ amount: string;
+ summary: string;
+ forcedCoinSel?: ForcedCoinSel;
+}
+
+```
+```typescript
+export interface TestPayResult {
+ payCoinSelection: PayCoinSelection;
+}
+
+```
+```typescript
+/**
+ * Result of selecting coins, contains the exchange, and selected
+ * coins with their denomination.
+ */
+export interface PayCoinSelection {
+ /**
+ * Amount requested by the merchant.
+ */
+ paymentAmount: AmountString;
+ /**
+ * Public keys of the coins that were selected.
+ */
+ coinPubs: string[];
+ /**
+ * Amount that each coin contributes.
+ */
+ coinContributions: AmountString[];
+ /**
+ * How much of the wire fees is the customer paying?
+ */
+ customerWireFees: AmountString;
+ /**
+ * How much of the deposit fees is the customer paying?
+ */
+ customerDepositFees: AmountString;
+}
+
+```
+
+### WithdrawFakebankOp
+```typescript
+/**
+ * Make a withdrawal from a fakebank, i.e.
+ * a bank where test users can be registered freely
+ * and testing APIs are available.
+ */
+export type WithdrawFakebankOp = {
+ op: WalletApiOperation.WithdrawFakebank;
+ request: WithdrawFakebankRequest;
+ response: EmptyObject;
+};
+// WithdrawFakebank = "withdrawFakebank"
+
+```
+```typescript
+export interface WithdrawFakebankRequest {
+ amount: AmountString;
+ exchange: string;
+ bank: string;
+}
+
+```
+
+### GetPendingTasksOp
+```typescript
+/**
+ * Get wallet-internal pending tasks.
+ */
+export type GetPendingTasksOp = {
+ op: WalletApiOperation.GetPendingOperations;
+ request: EmptyObject;
+ response: PendingTasksResponse;
+};
+// GetPendingOperations = "getPendingOperations"
+
+```
+```typescript
+/**
+ * Response returned from the pending operations API.
+ */
+export interface PendingOperationsResponse {
+ /**
+ * List of pending operations.
+ */
+ pendingOperations: PendingTaskInfo[];
+}
+
+```
+```typescript
+/**
+ * Information about a pending operation.
+ */
+export type PendingTaskInfo = PendingTaskInfoCommon &
+ (
+ | PendingExchangeUpdateTask
+ | PendingExchangeCheckRefreshTask
+ | PendingPurchaseTask
+ | PendingRefreshTask
+ | PendingTipPickupTask
+ | PendingWithdrawTask
+ | PendingRecoupTask
+ | PendingDepositTask
+ | PendingBackupTask
+ | PendingPeerPushInitiationTask
+ | PendingPeerPullInitiationTask
+ | PendingPeerPullDebitTask
+ | PendingPeerPushCreditTask
+ );
+
+```
+```typescript
+/**
+ * Fields that are present in every pending operation.
+ */
+export interface PendingTaskInfoCommon {
+ /**
+ * Type of the pending operation.
+ */
+ type: PendingTaskType;
+ /**
+ * Unique identifier for the pending task.
+ */
+ id: string;
+ /**
+ * Set to true if the operation indicates that something is really in
progress,
+ * as opposed to some regular scheduled operation that can be tried later.
+ */
+ givesLifeness: boolean;
+ /**
+ * Operation is active and waiting for a longpoll result.
+ */
+ isLongpolling: boolean;
+ /**
+ * Operation is waiting to be executed.
+ */
+ isDue: boolean;
+ /**
+ * Timestamp when the pending operation should be executed next.
+ */
+ timestampDue: AbsoluteTime;
+ /**
+ * Retry info. Currently used to stop the wallet after any operation
+ * exceeds a number of retries.
+ */
+ retryInfo?: RetryInfo;
+}
+
+```
+```typescript
+export enum PendingTaskType {
+ ExchangeUpdate = "exchange-update",
+ ExchangeCheckRefresh = "exchange-check-refresh",
+ Purchase = "purchase",
+ Refresh = "refresh",
+ Recoup = "recoup",
+ TipPickup = "tip-pickup",
+ Withdraw = "withdraw",
+ Deposit = "deposit",
+ Backup = "backup",
+ // FIXME: Rename to peer-push-debit and peer-pull-debit
+ PeerPushInitiation = "peer-push-initiation",
+ PeerPullInitiation = "peer-pull-initiation",
+ PeerPushCredit = "peer-push-credit",
+ PeerPullDebit = "peer-pull-debit",
+}
+
+```
+```typescript
+export interface RetryInfo {
+ firstTry: AbsoluteTime;
+ nextRetry: AbsoluteTime;
+ retryCounter: number;
+}
+
+```
+```typescript
+export interface RetryPolicy {
+ readonly backoffDelta: Duration;
+ readonly backoffBase: number;
+ readonly maxTimeout: Duration;
+}
+
+```
+```typescript
+// Declare "static" methods in Error
+interface ErrorConstructor {
+ /** Create .stack property on a target object */
+ captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+ /**
+ * Optional override for formatting stack traces
+ *
+ * @see https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+ */
+ prepareStackTrace?:
+ | ((err: Error, stackTraces: NodeJS.CallSite[]) => any)
+ | undefined;
+ stackTraceLimit: number;
+}
+
+```
+```typescript
+interface CallSite {
+ /**
+ * Value of "this"
+ */
+ getThis(): unknown;
+ /**
+ * Type of "this" as a string.
+ * This is the name of the function stored in the constructor field of
+ * "this", if available. Otherwise the object's [[Class]] internal
+ * property.
+ */
+ getTypeName(): string | null;
+ /**
+ * Current function
+ */
+ getFunction(): Function | undefined;
+ /**
+ * Name of the current function, typically its name property.
+ * If a name property is not available an attempt will be made to try
+ * to infer a name from the function's context.
+ */
+ getFunctionName(): string | null;
+ /**
+ * Name of the property [of "this" or one of its prototypes] that holds
+ * the current function
+ */
+ getMethodName(): string | null;
+ /**
+ * Name of the script [if this function was defined in a script]
+ */
+ getFileName(): string | null;
+ /**
+ * Current line number [if this function was defined in a script]
+ */
+ getLineNumber(): number | null;
+ /**
+ * Current column number [if this function was defined in a script]
+ */
+ getColumnNumber(): number | null;
+ /**
+ * A call site object representing the location where eval was called
+ * [if this function was created using a call to eval]
+ */
+ getEvalOrigin(): string | undefined;
+ /**
+ * Is this a toplevel invocation, that is, is "this" the global object?
+ */
+ isToplevel(): boolean;
+ /**
+ * Does this call take place in code defined by a call to eval?
+ */
+ isEval(): boolean;
+ /**
+ * Is this call in native V8 code?
+ */
+ isNative(): boolean;
+ /**
+ * Is this a constructor call?
+ */
+ isConstructor(): boolean;
+}
+
+```
+```typescript
+/**
+ * The wallet is currently updating information about an exchange.
+ */
+export interface PendingExchangeUpdateTask {
+ type: PendingTaskType.ExchangeUpdate;
+ exchangeBaseUrl: string;
+ lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+/**
+ * The wallet should check whether coins from this exchange
+ * need to be auto-refreshed.
+ */
+export interface PendingExchangeCheckRefreshTask {
+ type: PendingTaskType.ExchangeCheckRefresh;
+ exchangeBaseUrl: string;
+}
+
+```
+```typescript
+/**
+ * A purchase needs to be processed (i.e. for download / payment / refund).
+ */
+export interface PendingPurchaseTask {
+ type: PendingTaskType.Purchase;
+ proposalId: string;
+ retryInfo?: RetryInfo;
+ /**
+ * Status of the payment as string, used only for debugging.
+ */
+ statusStr: string;
+ lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+/**
+ * Status of an ongoing withdrawal operation.
+ */
+export interface PendingRefreshTask {
+ type: PendingTaskType.Refresh;
+ lastError?: TalerErrorDetail;
+ refreshGroupId: string;
+ finishedPerCoin: boolean[];
+ retryInfo?: RetryInfo;
+}
+
+```
+```typescript
+/**
+ * The wallet is picking up a tip that the user has accepted.
+ */
+export interface PendingTipPickupTask {
+ type: PendingTaskType.TipPickup;
+ tipId: string;
+ merchantBaseUrl: string;
+ merchantTipId: string;
+}
+
+```
+```typescript
+/**
+ * Status of an ongoing withdrawal operation.
+ */
+export interface PendingWithdrawTask {
+ type: PendingTaskType.Withdraw;
+ lastError: TalerErrorDetail | undefined;
+ retryInfo?: RetryInfo;
+ withdrawalGroupId: string;
+}
+
+```
+```typescript
+export interface PendingRecoupTask {
+ type: PendingTaskType.Recoup;
+ recoupGroupId: string;
+ retryInfo?: RetryInfo;
+ lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+/**
+ * Status of an ongoing deposit operation.
+ */
+export interface PendingDepositTask {
+ type: PendingTaskType.Deposit;
+ lastError: TalerErrorDetail | undefined;
+ retryInfo: RetryInfo | undefined;
+ depositGroupId: string;
+}
+
+```
+```typescript
+export interface PendingBackupTask {
+ type: PendingTaskType.Backup;
+ backupProviderBaseUrl: string;
+ lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+/**
+ * The wallet wants to send a peer push payment.
+ */
+export interface PendingPeerPushInitiationTask {
+ type: PendingTaskType.PeerPushInitiation;
+ pursePub: string;
+}
+
+```
+```typescript
+/**
+ * The wallet wants to send a peer pull payment.
+ */
+export interface PendingPeerPullInitiationTask {
+ type: PendingTaskType.PeerPullInitiation;
+ pursePub: string;
+}
+
+```
+```typescript
+/**
+ * The wallet wants to send a peer pull payment.
+ */
+export interface PendingPeerPullDebitTask {
+ type: PendingTaskType.PeerPullDebit;
+ peerPullPaymentIncomingId: string;
+}
+
+```
+```typescript
+/**
+ */
+export interface PendingPeerPushCreditTask {
+ type: PendingTaskType.PeerPushCredit;
+ peerPushPaymentIncomingId: string;
+}
+
+```
+
+### DumpCoinsOp
+```typescript
+/**
+ * Dump all coins of the wallet in a simple JSON format.
+ */
+export type DumpCoinsOp = {
+ op: WalletApiOperation.DumpCoins;
+ request: EmptyObject;
+ response: CoinDumpJson;
+};
+// DumpCoins = "dumpCoins"
+
+```
+```typescript
+/**
+ * Easy to process format for the public data of coins
+ * managed by the wallet.
+ */
+export interface CoinDumpJson {
+ coins: Array<{
+ /**
+ * The coin's denomination's public key.
+ */
+ denom_pub: DenominationPubKey;
+ /**
+ * Hash of denom_pub.
+ */
+ denom_pub_hash: string;
+ /**
+ * Value of the denomination (without any fees).
+ */
+ denom_value: string;
+ /**
+ * Public key of the coin.
+ */
+ coin_pub: string;
+ /**
+ * Base URL of the exchange for the coin.
+ */
+ exchange_base_url: string;
+ /**
+ * Public key of the parent coin.
+ * Only present if this coin was obtained via refreshing.
+ */
+ refresh_parent_coin_pub: string | undefined;
+ /**
+ * Public key of the reserve for this coin.
+ * Only present if this coin was obtained via refreshing.
+ */
+ withdrawal_reserve_pub: string | undefined;
+ coin_status: CoinStatus;
+ spend_allocation:
+ | {
+ id: string;
+ amount: string;
+ }
+ | undefined;
+ /**
+ * Information about the age restriction
+ */
+ ageCommitmentProof: AgeCommitmentProof | undefined;
+ }>;
+}
+
+```
+```typescript
+export type DenominationPubKey = RsaDenominationPubKey | CsDenominationPubKey;
+
+```
+```typescript
+export interface RsaDenominationPubKey {
+ readonly cipher: DenomKeyType.Rsa;
+ readonly rsa_public_key: string;
+ readonly age_mask: number;
+}
+
+```
+```typescript
+export interface CsDenominationPubKey {
+ readonly cipher: DenomKeyType.ClauseSchnorr;
+ readonly age_mask: number;
+ readonly cs_public_key: string;
+}
+
+```
+```typescript
+/**
+ * Status of a coin.
+ */
+export declare enum CoinStatus {
+ /**
+ * Withdrawn and never shown to anybody.
+ */
+ Fresh = "fresh",
+ /**
+ * Fresh, but currently marked as "suspended", thus won't be used
+ * for spending. Used for testing.
+ */
+ FreshSuspended = "fresh-suspended",
+ /**
+ * A coin that has been spent and refreshed.
+ */
+ Dormant = "dormant",
+}
+
+```
+```typescript
+export interface AgeCommitmentProof {
+ commitment: AgeCommitment;
+ proof: AgeProof;
+}
+
+```
+```typescript
+export interface AgeCommitment {
+ mask: number;
+ /**
+ * Public keys, one for each age group specified in the age mask.
+ */
+ publicKeys: Edx25519PublicKeyEnc[];
+}
+
+```
+```typescript
+export type Edx25519PublicKeyEnc = FlavorP<string, "Edx25519PublicKeyEnc", 32>;
+
+```
+```typescript
+export type FlavorP<T, FlavorT extends string, S extends number> = T & {
+ _flavor?: `taler.${FlavorT}`;
+ _size?: S;
+};
+
+```
+```typescript
+export interface AgeProof {
+ /**
+ * Private keys. Typically smaller than the number of public keys,
+ * because we drop private keys from age groups that are restricted.
+ */
+ privateKeys: Edx25519PrivateKeyEnc[];
+}
+
+```
+```typescript
+export type Edx25519PrivateKeyEnc = FlavorP<
+ string,
+ "Edx25519PrivateKeyEnc",
+ 64
+>;
+
+```
+
+### SetCoinSuspendedOp
+```typescript
+/**
+ * Set a coin as (un-)suspended.
+ * Suspended coins won't be used for payments.
+ */
+export type SetCoinSuspendedOp = {
+ op: WalletApiOperation.SetCoinSuspended;
+ request: SetCoinSuspendedRequest;
+ response: EmptyObject;
+};
+// SetCoinSuspended = "setCoinSuspended"
+
+```
+```typescript
+export interface SetCoinSuspendedRequest {
+ coinPub: string;
+ suspended: boolean;
+}
+
+```
+
+### ForceRefreshOp
+```typescript
+/**
+ * Force a refresh on coins where it would not
+ * be necessary.
+ */
+export type ForceRefreshOp = {
+ op: WalletApiOperation.ForceRefresh;
+ request: ForceRefreshRequest;
+ response: EmptyObject;
+};
+// ForceRefresh = "forceRefresh"
+
+```
+```typescript
+export interface ForceRefreshRequest {
+ coinPubList: string[];
+}
+
+```
+
+## Common Declarations
+```typescript
+export interface WalletCoreVersion {
+ hash: string | undefined;
+ version: string;
+ exchange: string;
+ merchant: string;
+ bank: string;
+ /**
+ * @deprecated will be removed
+ */
+ devMode: boolean;
+}
+```
+```typescript
+export type Transaction =
+ | TransactionWithdrawal
+ | TransactionPayment
+ | TransactionRefund
+ | TransactionTip
+ | TransactionRefresh
+ | TransactionDeposit
+ | TransactionPeerPullCredit
+ | TransactionPeerPullDebit
+ | TransactionPeerPushCredit
+ | TransactionPeerPushDebit;
+```
+```typescript
+export interface TransactionWithdrawal extends TransactionCommon {
+ type: TransactionType.Withdrawal;
+ /**
+ * Exchange of the withdrawal.
+ */
+ exchangeBaseUrl: string;
+ /**
+ * Amount that got subtracted from the reserve balance.
+ */
+ amountRaw: AmountString;
+ /**
+ * Amount that actually was (or will be) added to the wallet's balance.
+ */
+ amountEffective: AmountString;
+ withdrawalDetails: WithdrawalDetails;
+}
+```
+```typescript
+export interface TransactionCommon {
+ transactionId: TransactionIdStr;
+ type: TransactionType;
+ timestamp: TalerProtocolTimestamp;
+ /**
+ * Transaction state, as per DD37.
+ */
+ txState: TransactionState;
+ /**
+ * @deprecated in favor of statusMajor and statusMinor
+ */
+ extendedStatus: ExtendedStatus;
+ /**
+ * true if the transaction is still pending, false otherwise
+ * If a transaction is not longer pending, its timestamp will be updated,
+ * but its transactionId will remain unchanged
+ *
+ * @deprecated show extendedStatus
+ */
+ pending: boolean;
+ /**
+ * True if the transaction encountered a problem that might be
+ * permanent. A frozen transaction won't be automatically retried.
+ *
+ * @deprecated show extendedStatus
+ */
+ frozen: boolean;
+ /**
+ * Raw amount of the transaction (exclusive of fees or other extra costs).
+ */
+ amountRaw: AmountString;
+ /**
+ * Amount added or removed from the wallet's balance (including all fees and
other costs).
+ */
+ amountEffective: AmountString;
+ error?: TalerErrorDetail;
+}
+```
+```typescript
+export declare enum TransactionType {
+ Withdrawal = "withdrawal",
+ Payment = "payment",
+ Refund = "refund",
+ Refresh = "refresh",
+ Tip = "tip",
+ Deposit = "deposit",
+ PeerPushDebit = "peer-push-debit",
+ PeerPushCredit = "peer-push-credit",
+ PeerPullDebit = "peer-pull-debit",
+ PeerPullCredit = "peer-pull-credit",
+}
+```
+```typescript
+export interface TalerProtocolTimestamp {
+ readonly t_s: number | "never";
+}
+```
+```typescript
+export interface TransactionState {
+ major: TransactionMajorState;
+ minor?: TransactionMinorState;
+}
+```
+```typescript
+export declare enum TransactionMajorState {
+ None = "none",
+ Pending = "pending",
+ Done = "done",
+ Aborting = "aborting",
+ Aborted = "aborted",
+ Suspended = "suspended",
+ Failed = "failed",
+ Deleted = "deleted",
+ Unknown = "unknown",
+}
+```
+```typescript
+export declare enum TransactionMinorState {
+ Unknown = "unknown",
+ Deposit = "deposit",
+ KycRequired = "kyc-required",
+ Track = "track",
+ Refresh = "refresh",
+}
+```
+```typescript
+export declare enum ExtendedStatus {
+ Pending = "pending",
+ Done = "done",
+ Aborting = "aborting",
+ Aborted = "aborted",
+ Failed = "failed",
+ KycRequired = "kyc-required",
+}
+```
+```typescript
+export interface TalerErrorDetail {
+ code: TalerErrorCode;
+ when?: AbsoluteTime;
+ hint?: string;
+ [x: string]: unknown;
+}
+```
+```typescript
+export interface AbsoluteTime {
+ /**
+ * Timestamp in milliseconds.
+ */
+ readonly t_ms: number | "never";
+}
+```
+```typescript
+export interface Duration {
+ /**
+ * Duration in milliseconds.
+ */
+ readonly d_ms: number | "forever";
+}
+```
+```typescript
+export interface TalerProtocolDuration {
+ readonly d_us: number | "forever";
+}
+```
+```typescript
+export type WithdrawalDetails =
+ | WithdrawalDetailsForManualTransfer
+ | WithdrawalDetailsForTalerBankIntegrationApi;
+```
+```typescript
+interface WithdrawalDetailsForManualTransfer {
+ type: WithdrawalType.ManualTransfer;
+ /**
+ * Payto URIs that the exchange supports.
+ *
+ * Already contains the amount and message.
+ */
+ exchangePaytoUris: string[];
+ reservePub: string;
+ /**
+ * Is the reserve ready for withdrawal?
+ */
+ reserveIsReady: boolean;
+}
+```
+```typescript
+interface WithdrawalDetailsForTalerBankIntegrationApi {
+ type: WithdrawalType.TalerBankIntegrationApi;
+ /**
+ * Set to true if the bank has confirmed the withdrawal, false if not.
+ * An unconfirmed withdrawal usually requires user-input and should be
highlighted in the UI.
+ * See also bankConfirmationUrl below.
+ */
+ confirmed: boolean;
+ /**
+ * If the withdrawal is unconfirmed, this can include a URL for user
+ * initiated confirmation.
+ */
+ bankConfirmationUrl?: string;
+ reservePub: string;
+ /**
+ * Is the reserve ready for withdrawal?
+ */
+ reserveIsReady: boolean;
+}
+```
+```typescript
+export interface TransactionPayment extends TransactionCommon {
+ type: TransactionType.Payment;
+ /**
+ * Additional information about the payment.
+ */
+ info: OrderShortInfo;
+ /**
+ * Wallet-internal end-to-end identifier for the payment.
+ */
+ proposalId: string;
+ /**
+ * How far did the wallet get with processing the payment?
+ *
+ * @deprecated use extendedStatus
+ */
+ status: PaymentStatus;
+ /**
+ * Amount that must be paid for the contract
+ */
+ amountRaw: AmountString;
+ /**
+ * Amount that was paid, including deposit, wire and refresh fees.
+ */
+ amountEffective: AmountString;
+ /**
+ * Amount that has been refunded by the merchant
+ */
+ totalRefundRaw: AmountString;
+ /**
+ * Amount will be added to the wallet's balance after fees and refreshing
+ */
+ totalRefundEffective: AmountString;
+ /**
+ * Amount pending to be picked up
+ */
+ refundPending: AmountString | undefined;
+ /**
+ * Reference to applied refunds
+ */
+ refunds: RefundInfoShort[];
+ /**
+ * Is the wallet currently checking for a refund?
+ */
+ refundQueryActive: boolean;
+ /**
+ * Does this purchase has an pos validation
+ */
+ posConfirmation: string | undefined;
+}
+```
+```typescript
+export interface OrderShortInfo {
+ /**
+ * Order ID, uniquely identifies the order within a merchant instance
+ */
+ orderId: string;
+ /**
+ * Hash of the contract terms.
+ */
+ contractTermsHash: string;
+ /**
+ * More information about the merchant
+ */
+ merchant: MerchantInfo;
+ /**
+ * Summary of the order, given by the merchant
+ */
+ summary: string;
+ /**
+ * Map from IETF BCP 47 language tags to localized summaries
+ */
+ summary_i18n?: InternationalizedString;
+ /**
+ * List of products that are part of the order
+ */
+ products: Product[] | undefined;
+ /**
+ * Time indicating when the order should be delivered.
+ * May be overwritten by individual products.
+ */
+ delivery_date?: TalerProtocolTimestamp;
+ /**
+ * Delivery location for (all!) products.
+ */
+ delivery_location?: Location;
+ /**
+ * URL of the fulfillment, given by the merchant
+ */
+ fulfillmentUrl?: string;
+ /**
+ * Plain text message that should be shown to the user
+ * when the payment is complete.
+ */
+ fulfillmentMessage?: string;
+ /**
+ * Translations of fulfillmentMessage.
+ */
+ fulfillmentMessage_i18n?: InternationalizedString;
+}
+```
+```typescript
+export interface MerchantInfo {
+ name: string;
+ jurisdiction?: Location;
+ address?: Location;
+ logo?: string;
+ website?: string;
+ email?: string;
+}
+```
+```typescript
+export interface Location {
+ country?: string;
+ country_subdivision?: string;
+ district?: string;
+ town?: string;
+ town_location?: string;
+ post_code?: string;
+ street?: string;
+ building_name?: string;
+ building_number?: string;
+ address_lines?: string[];
+}
+```
+```typescript
+export interface InternationalizedString {
+ [lang_tag: string]: string;
+}
+```
+```typescript
+export interface Product {
+ product_id?: string;
+ description: string;
+ description_i18n?: {
+ [lang_tag: string]: string;
+ };
+ quantity?: number;
+ unit?: string;
+ price?: AmountString;
+ image?: string;
+ taxes?: Tax[];
+ delivery_date?: TalerProtocolTimestamp;
+}
+```
+```typescript
+export interface Tax {
+ name: string;
+ tax: AmountString;
+}
+```
+```typescript
+export declare enum PaymentStatus {
+ /**
+ * Explicitly aborted after timeout / failure
+ */
+ Aborted = "aborted",
+ /**
+ * Payment failed, wallet will auto-retry.
+ * User should be given the option to retry now / abort.
+ */
+ Failed = "failed",
+ /**
+ * Paid successfully
+ */
+ Paid = "paid",
+ /**
+ * User accepted, payment is processing.
+ */
+ Accepted = "accepted",
+}
+```
+```typescript
+export interface RefundInfoShort {
+ transactionId: string;
+ timestamp: TalerProtocolTimestamp;
+ amountEffective: AmountString;
+ amountRaw: AmountString;
+}
+```
+```typescript
+export interface TransactionRefund extends TransactionCommon {
+ type: TransactionType.Refund;
+ refundedTransactionId: string;
+ info: OrderShortInfo;
+ /**
+ * Amount pending to be picked up
+ */
+ refundPending: AmountString | undefined;
+ amountRaw: AmountString;
+ amountEffective: AmountString;
+}
+```
+```typescript
+export interface TransactionTip extends TransactionCommon {
+ type: TransactionType.Tip;
+ amountRaw: AmountString;
+ /**
+ * More information about the merchant
+ */
+ amountEffective: AmountString;
+ merchantBaseUrl: string;
+}
+```
+```typescript
+/**
+ * A transaction shown for refreshes.
+ * Only shown for (1) refreshes not associated with other transactions
+ * and (2) refreshes in an error state.
+ */
+export interface TransactionRefresh extends TransactionCommon {
+ type: TransactionType.Refresh;
+ refreshReason: RefreshReason;
+ /**
+ * Transaction ID that caused this refresh.
+ */
+ originatingTransactionId?: string;
+ /**
+ * Always zero for refreshes
+ */
+ amountRaw: AmountString;
+ /**
+ * Fees, i.e. the effective, negative effect of the refresh
+ * on the balance.
+ *
+ * Only applicable for stand-alone refreshes, and zero for
+ * other refreshes where the transaction itself accounts for the
+ * refresh fee.
+ */
+ amountEffective: AmountString;
+ refreshInputAmount: AmountString;
+ refreshOutputAmount: AmountString;
+}
+```
+```typescript
+/**
+ * Reasons for why a coin is being refreshed.
+ */
+export declare enum RefreshReason {
+ Manual = "manual",
+ PayMerchant = "pay-merchant",
+ PayDeposit = "pay-deposit",
+ PayPeerPush = "pay-peer-push",
+ PayPeerPull = "pay-peer-pull",
+ Refund = "refund",
+ AbortPay = "abort-pay",
+ AbortDeposit = "abort-deposit",
+ Recoup = "recoup",
+ BackupRestored = "backup-restored",
+ Scheduled = "scheduled",
+}
+```
+```typescript
+/**
+ * Deposit transaction, which effectively sends
+ * money from this wallet somewhere else.
+ */
+export interface TransactionDeposit extends TransactionCommon {
+ type: TransactionType.Deposit;
+ depositGroupId: string;
+ /**
+ * Target for the deposit.
+ */
+ targetPaytoUri: string;
+ /**
+ * Raw amount that is being deposited
+ */
+ amountRaw: AmountString;
+ /**
+ * Effective amount that is being deposited
+ */
+ amountEffective: AmountString;
+ wireTransferDeadline: TalerProtocolTimestamp;
+ wireTransferProgress: number;
+ /**
+ * Did all the deposit requests succeed?
+ */
+ deposited: boolean;
+ trackingState: Array<{
+ wireTransferId: string;
+ timestampExecuted: TalerProtocolTimestamp;
+ amountRaw: AmountString;
+ wireFee: AmountString;
+ }>;
+}
+```
+```typescript
+/**
+ * Credit because we were paid for a P2P invoice we created.
+ */
+export interface TransactionPeerPullCredit extends TransactionCommon {
+ type: TransactionType.PeerPullCredit;
+ info: PeerInfoShort;
+ /**
+ * Exchange used.
+ */
+ exchangeBaseUrl: string;
+ /**
+ * Amount that got subtracted from the reserve balance.
+ */
+ amountRaw: AmountString;
+ /**
+ * Amount that actually was (or will be) added to the wallet's balance.
+ */
+ amountEffective: AmountString;
+ /**
+ * URI to send to the other party.
+ */
+ talerUri: string;
+}
+```
+```typescript
+export interface PeerInfoShort {
+ expiration: TalerProtocolTimestamp | undefined;
+ summary: string | undefined;
+}
+```
+```typescript
+/**
+ * Debit because we paid someone's invoice.
+ */
+export interface TransactionPeerPullDebit extends TransactionCommon {
+ type: TransactionType.PeerPullDebit;
+ info: PeerInfoShort;
+ /**
+ * Exchange used.
+ */
+ exchangeBaseUrl: string;
+ amountRaw: AmountString;
+ amountEffective: AmountString;
+}
+```
+```typescript
+/**
+ * We received money via a P2P payment.
+ */
+export interface TransactionPeerPushCredit extends TransactionCommon {
+ type: TransactionType.PeerPushCredit;
+ info: PeerInfoShort;
+ /**
+ * Exchange used.
+ */
+ exchangeBaseUrl: string;
+ /**
+ * Amount that got subtracted from the reserve balance.
+ */
+ amountRaw: AmountString;
+ /**
+ * Amount that actually was (or will be) added to the wallet's balance.
+ */
+ amountEffective: AmountString;
+}
+```
+```typescript
+/**
+ * We sent money via a P2P payment.
+ */
+export interface TransactionPeerPushDebit extends TransactionCommon {
+ type: TransactionType.PeerPushDebit;
+ info: PeerInfoShort;
+ /**
+ * Exchange used.
+ */
+ exchangeBaseUrl: string;
+ /**
+ * Amount that got subtracted from the reserve balance.
+ */
+ amountRaw: AmountString;
+ /**
+ * Amount that actually was (or will be) added to the wallet's balance.
+ */
+ amountEffective: AmountString;
+ /**
+ * URI to accept the payment.
+ */
+ talerUri: string;
+}
+```
+```typescript
+export interface AbortTransactionRequest {
+ transactionId: string;
+ /**
+ * Move the payment immediately into an aborted state.
+ * The UI should warn the user that this might lead
+ * to money being lost.
+ *
+ * Defaults to false.
+ */
+ forceImmediateAbort?: boolean;
+}
+```
+```typescript
+export interface ExchangeListItem {
+ exchangeBaseUrl: string;
+ currency: string | undefined;
+ paytoUris: string[];
+ tosStatus: ExchangeTosStatus;
+ exchangeStatus: ExchangeEntryStatus;
+ ageRestrictionOptions: number[];
+ /**
+ * Permanently added to the wallet, as opposed to just
+ * temporarily queried.
+ */
+ permanent: boolean;
+ /**
+ * Information about the last error that occurred when trying
+ * to update the exchange info.
+ */
+ lastUpdateErrorInfo?: OperationErrorInfo;
+}
+```
+```typescript
+export declare enum ExchangeTosStatus {
+ New = "new",
+ Accepted = "accepted",
+ Changed = "changed",
+ NotFound = "not-found",
+ Unknown = "unknown",
+}
+```
+```typescript
+export declare enum ExchangeEntryStatus {
+ Unknown = "unknown",
+ Outdated = "outdated",
+ Ok = "ok",
+}
+```
+```typescript
+export interface OperationErrorInfo {
+ error: TalerErrorDetail;
+}
+```
+```typescript
+export interface ForcedDenomSel {
+ denoms: {
+ value: AmountString;
+ count: number;
+ }[];
+}
+```
+```typescript
+/**
+ * Result of a prepare pay operation.
+ */
+export type PreparePayResult =
+ | PreparePayResultInsufficientBalance
+ | PreparePayResultAlreadyConfirmed
+ | PreparePayResultPaymentPossible;
+```
+```typescript
+export interface PreparePayResultInsufficientBalance {
+ status: PreparePayResultType.InsufficientBalance;
+ proposalId: string;
+ contractTerms: MerchantContractTerms;
+ amountRaw: string;
+ noncePriv: string;
+ talerUri: string;
+ balanceDetails: PayMerchantInsufficientBalanceDetails;
+}
+```
+```typescript
+/**
+ * Contract terms from a merchant.
+ * FIXME: Add type field!
+ */
+export interface MerchantContractTerms {
+ /**
+ * Hash of the merchant's wire details.
+ */
+ h_wire: string;
+ /**
+ * Hash of the merchant's wire details.
+ */
+ auto_refund?: TalerProtocolDuration;
+ /**
+ * Wire method the merchant wants to use.
+ */
+ wire_method: string;
+ /**
+ * Human-readable short summary of the contract.
+ */
+ summary: string;
+ summary_i18n?: InternationalizedString;
+ /**
+ * Nonce used to ensure freshness.
+ */
+ nonce: string;
+ /**
+ * Total amount payable.
+ */
+ amount: string;
+ /**
+ * Auditors accepted by the merchant.
+ */
+ auditors: AuditorHandle[];
+ /**
+ * Deadline to pay for the contract.
+ */
+ pay_deadline: TalerProtocolTimestamp;
+ /**
+ * Maximum deposit fee covered by the merchant.
+ */
+ max_fee: string;
+ /**
+ * Information about the merchant.
+ */
+ merchant: MerchantInfo;
+ /**
+ * Public key of the merchant.
+ */
+ merchant_pub: string;
+ /**
+ * Time indicating when the order should be delivered.
+ * May be overwritten by individual products.
+ */
+ delivery_date?: TalerProtocolTimestamp;
+ /**
+ * Delivery location for (all!) products.
+ */
+ delivery_location?: Location;
+ /**
+ * List of accepted exchanges.
+ */
+ exchanges: ExchangeHandle[];
+ /**
+ * Products that are sold in this contract.
+ */
+ products?: Product[];
+ /**
+ * Deadline for refunds.
+ */
+ refund_deadline: TalerProtocolTimestamp;
+ /**
+ * Deadline for the wire transfer.
+ */
+ wire_transfer_deadline: TalerProtocolTimestamp;
+ /**
+ * Time when the contract was generated by the merchant.
+ */
+ timestamp: TalerProtocolTimestamp;
+ /**
+ * Order id to uniquely identify the purchase within
+ * one merchant instance.
+ */
+ order_id: string;
+ /**
+ * Base URL of the merchant's backend.
+ */
+ merchant_base_url: string;
+ /**
+ * Fulfillment URL to view the product or
+ * delivery status.
+ */
+ fulfillment_url?: string;
+ /**
+ * URL meant to share the shopping cart.
+ */
+ public_reorder_url?: string;
+ /**
+ * Plain text fulfillment message in the merchant's default language.
+ */
+ fulfillment_message?: string;
+ /**
+ * Internationalized fulfillment messages.
+ */
+ fulfillment_message_i18n?: InternationalizedString;
+ /**
+ * Share of the wire fee that must be settled with one payment.
+ */
+ wire_fee_amortization?: number;
+ /**
+ * Maximum wire fee that the merchant agrees to pay for.
+ */
+ max_wire_fee?: string;
+ minimum_age?: number;
+ /**
+ * Extra data, interpreted by the mechant only.
+ */
+ extra?: any;
+}
+```
+```typescript
+export interface AuditorHandle {
+ /**
+ * Official name of the auditor.
+ */
+ name: string;
+ /**
+ * Master public signing key of the auditor.
+ */
+ auditor_pub: string;
+ /**
+ * Base URL of the auditor.
+ */
+ url: string;
+}
+```
+```typescript
+/**
+ * Information about an exchange as stored inside a
+ * merchant's contract terms.
+ */
+export interface ExchangeHandle {
+ /**
+ * Master public signing key of the exchange.
+ */
+ master_pub: string;
+ /**
+ * Base URL of the exchange.
+ */
+ url: string;
+}
+```
+```typescript
+/**
+ * Detailed reason for why the wallet's balance is insufficient.
+ */
+export interface PayMerchantInsufficientBalanceDetails {
+ /**
+ * Amount requested by the merchant.
+ */
+ amountRequested: AmountString;
+ /**
+ * Balance of type "available" (see balance.ts for definition).
+ */
+ balanceAvailable: AmountString;
+ /**
+ * Balance of type "material" (see balance.ts for definition).
+ */
+ balanceMaterial: AmountString;
+ /**
+ * Balance of type "age-acceptable" (see balance.ts for definition).
+ */
+ balanceAgeAcceptable: AmountString;
+ /**
+ * Balance of type "merchant-acceptable" (see balance.ts for definition).
+ */
+ balanceMerchantAcceptable: AmountString;
+ /**
+ * Balance of type "merchant-depositable" (see balance.ts for definition).
+ */
+ balanceMerchantDepositable: AmountString;
+ /**
+ * If the payment would succeed without fees
+ * (i.e. balanceMerchantDepositable >= amountRequested),
+ * this field contains an estimate of the amount that would additionally
+ * be required to cover the fees.
+ *
+ * It is not possible to give an exact value here, since it depends
+ * on the coin selection for the amount that would be additionally withdrawn.
+ */
+ feeGapEstimate: AmountString;
+}
+```
+```typescript
+export interface PreparePayResultAlreadyConfirmed {
+ status: PreparePayResultType.AlreadyConfirmed;
+ contractTerms: MerchantContractTerms;
+ paid: boolean;
+ amountRaw: string;
+ amountEffective: string;
+ contractTermsHash: string;
+ proposalId: string;
+ talerUri?: string;
+}
+```
+```typescript
+/**
+ * Payment is possible.
+ */
+export interface PreparePayResultPaymentPossible {
+ status: PreparePayResultType.PaymentPossible;
+ proposalId: string;
+ contractTerms: MerchantContractTerms;
+ contractTermsHash: string;
+ amountRaw: string;
+ amountEffective: string;
+ noncePriv: string;
+ talerUri: string;
+}
+```
+```typescript
+/**
+ * Forced coin selection for deposits/payments.
+ */
+export interface ForcedCoinSel {
+ coins: {
+ value: AmountString;
+ contribution: AmountString;
+ }[];
+}
+```
+```typescript
+export interface ApplyRefundResponse {
+ contractTermsHash: string;
+ transactionId: string;
+ proposalId: string;
+ amountEffectivePaid: AmountString;
+ amountRefundGranted: AmountString;
+ amountRefundGone: AmountString;
+ pendingAtExchange: boolean;
+ info: OrderShortInfo;
+}
+```
+```typescript
+export interface AddExchangeRequest {
+ exchangeBaseUrl: string;
+ forceUpdate?: boolean;
+}
+```
+```typescript
+export interface BackupRecovery {
+ walletRootPriv: string;
+ providers: {
+ name: string;
+ url: string;
+ }[];
+}
+```
+```typescript
+/**
+ * Contract terms between two wallets (as opposed to a merchant and wallet).
+ */
+export interface PeerContractTerms {
+ amount: AmountString;
+ summary: string;
+ purse_expiration: TalerProtocolTimestamp;
+}
+```
+```typescript
+export interface IntegrationTestArgs {
+ exchangeBaseUrl: string;
+ bankAccessApiBaseUrl: string;
+ merchantBaseUrl: string;
+ merchantAuthToken?: string;
+ amountToWithdraw: string;
+ amountToSpend: string;
+}
+```
diff --git a/transaction-deposit-states.dot b/transaction-deposit-states.dot
index a6e7620..fa8d91d 100644
--- a/transaction-deposit-states.dot
+++ b/transaction-deposit-states.dot
@@ -1,59 +1,44 @@
digraph G {
- initial[label="", shape="circle"];
- pending_deposit[label="pending(deposit)"];
- suspended_deposit[label="suspended(deposit)", shape="box"];
- pending_track[label="pending(track)"];
- pending_kyc[label="pending(kyc)"];
- suspended_kyc[label="suspended(kyc)", shape="box"];
- pending_aml[label="pending(aml)"];
- suspended_aml[label="suspended(aml)", shape="box"];
- aborting_refresh[label="aborting(refresh)"];
- aborting_refund[label="aborting(refund)"];
-
+ initial[label="", shape="circle", xlabel="deposit"];
+ pending_deposit[label="deposit"];
+ pending_track[label="track"];
+ pending_kyc[label="kyc"];
+ pending_aml[label="aml"];
+ aborting_refresh[label="refresh", style=dashed];
+ aborting_refund[label="refund", style=dashed];
done[label="done", shape="box"];
- aborted[label="aborted", shape="box"];
- suspended_abort_refund[label="suspended(refund)", shape="box"];
- suspended_abort_refresh[label="suspended(refresh)", shape="box"];
- deleted[label="deleted", shape="box"];
-
- initial->pending_deposit [color="blue", label="deposit form data"];
- aborting_refresh->suspended_abort_refresh [color="blue", label="suspend"];
- aborting_refund->suspended_abort_refund [color="blue", label="suspend"];
- aborting_refund->aborting_refresh;
- aborting_refresh->aborted;
-
- pending_deposit->pending_track;
- pending_deposit->aborting_refund [color="red", label="failure"];
- pending_deposit->suspended_deposit [color="blue", label="suspend"];
-
- pending_track->aborting_refund [color="blue", label="abort"];
- pending_track->done;
- pending_track->pending_kyc;
- pending_track->pending_aml;
-
- pending_kyc->suspended_kyc [color="blue", label="suspend"];
- pending_kyc->done [color="purple", label="long-poll:kyc"];
+ aborted[label="aborted", shape="box", style=dashed];
- suspended_kyc->pending_kyc [color="blue", label="resume"];
- suspended_kyc->deleted [color="blue", label="force-delete"];
+ subgraph {
+ rank=same;
+ done; aborted;
+ }
- pending_aml->suspended_aml [color="blue", label="suspend"];
- pending_aml->done [color="purple", label="long-poll:aml"];
+ subgraph {
+ rank=same;
+ pending_track; aborting_refund;
+ }
- suspended_aml->pending_kyc [color="blue", label="resume"];
- suspended_aml->deleted [color="blue", label="force-delete"];
+ subgraph {
+ rank=same;
+ pending_deposit; pending_kyc; pending_aml;
+ }
- suspended_abort_refund->aborting_refund [color="blue", label="resume"];
- suspended_abort_refresh->aborting_refresh [color="blue", label="resume"];
- suspended_abort_refund->deleted [color="blue", label="force-delete"];
- suspended_abort_refresh->deleted [color="blue", label="force-delete"];
+ initial->pending_deposit;
+ aborting_refund->aborting_refresh [color=green];
+ aborting_refresh->aborted [color=green];
- suspended_deposit->pending_deposit [color="blue", label="resume"];
- suspended_deposit->aborting_refund [color="blue", label="abort"];
+ pending_deposit->pending_track [color=green];
+ pending_deposit->aborting_refund [color="red"];
+ pending_deposit->aborting_refund [color="blue", style=dashed];
- done->deleted [color="blue", label="delete"];
- aborted->deleted [color="blue", label="delete"];
+ pending_track->aborting_refund [color="blue", style=dashed];
+ pending_track->done [color=green];
+ pending_track->pending_kyc [color=red];
+ pending_track->pending_aml [color=red];
+ pending_kyc->pending_track [color="green"];
+ pending_aml->pending_track [color="green"];
}
diff --git a/transaction-refresh-states.dot b/transaction-refresh-states.dot
index ab0462b..4b67c88 100644
--- a/transaction-refresh-states.dot
+++ b/transaction-refresh-states.dot
@@ -1,22 +1,27 @@
digraph G {
- initial[label="", shape="circle"];
- pending[label="pending"];
- suspended[label="suspended", shape="box"];
+ initial[label="", shape="circle", xlabel="refresh"];
+ pending[label="refresh"];
+ //aborting[label="refresh", style=dashed];
+ //aborted[style=dashed];
done[label="done", shape="box"];
- failed[label="failed", shape="box"];
- deleted[label="deleted", shape="box"];
- initial->pending [color="blue", label="trigger"];
+ subgraph {
+ rank=same;
+ pending;
+ // aborting;
+ }
+
+ subgraph {
+ rank=same;
+ done;
+ //aborted;
+ }
- pending->done;
- pending->suspended [color="blue", label="suspend"];
- pending->failed [color="red", label="failure"];
-
- suspended->pending [color="blue", label="resume"];
- suspended->deleted [color="blue", label="force-delete"];
-
- failed->deleted [color="blue", label="delete"];
- done->deleted [color="blue", label="delete"];
+ initial->pending;
+
+ //pending -> aborting [color=blue, style=dashed, label="abort"];
+ //aborting->aborted;
+ pending->done [color=green];
}
diff --git a/transaction-refund-states.dot b/transaction-refund-states.dot
index 27aba41..8e01d6e 100644
--- a/transaction-refund-states.dot
+++ b/transaction-refund-states.dot
@@ -3,29 +3,17 @@ digraph G {
initial[label="", shape="circle", xlabel="refund"];
pending_merchant[label="merchant"];
pending_refresh[label="refresh"];
- aborting_merchant[label="merchant", style=dashed];
- aborting_refresh[label="refresh",style=dashed];
- aborted[label="aborted", style=dashed, shape=box];
+ //aborting_merchant[label="merchant", style=dashed];
+ //aborting_refresh[label="refresh",style=dashed];
+ //aborted[label="aborted", style=dashed, shape=box];
done[label="done", shape="box"];
- subgraph {
- rank=same; aborted; done;
- }
-
- subgraph {
- rank=same; pending_merchant; aborting_merchant;
- }
-
- subgraph {
- rank=same; pending_refresh; aborting_refresh;
- }
-
initial->pending_merchant;
pending_merchant->pending_refresh [color=green];
- pending_merchant -> aborting_merchant [color=blue, style=dashed];
- aborting_merchant -> aborted [color=green];
- pending_refresh -> aborting_refresh [color=blue];
- aborting_refresh -> aborted [color=green];
- pending_refresh -> done;
+ //pending_merchant -> aborting_merchant [color=blue, style=dashed];
+ //aborting_merchant -> aborted [color=green];
+ //pending_refresh -> aborting_refresh [color=blue];
+ //aborting_refresh -> aborted [color=green];
+ pending_refresh -> done [color=green];
}
diff --git a/transaction-tip-states.dot b/transaction-tip-states.dot
index 9bf5e87..a4625d8 100644
--- a/transaction-tip-states.dot
+++ b/transaction-tip-states.dot
@@ -1,47 +1,36 @@
digraph G {
initial[label="", shape="circle"];
- pending_query[label="pending(query)"];
- pending_user[label="pending(user)"];
- pending_pickup[label="pending(pickup)"];
- pending_kyc[label="pending(kyc)"];
- suspended_query[label="suspended(query)", shape="box"];
- suspended_pickup[label="suspended(pickup)", shape="box"];
- suspended_kyc[label="suspended(kyc)", shape="box"];
+ pending_query[label="query"];
+ //aborting_query[label="query", style=dashed];
+ //aborted_query[label="aborted", style=dashed, shape=box];
+ monolog_user[label="monolog(user)"];
+ pending_pickup[label="pickup"];
+ //aborting_pickup[label="pickup", style=dashed];
+ //aborted_pickup[label="aborted", style=dashed, shape=box];
done[label="done", shape="box"];
- failed[label="failed", shape="box"];
- deleted[label="deleted", shape="box"];
-
- initial->pending_query [color="blue", label="URI trigger"];
-
- pending_query->pending_user;
- pending_query->suspended_query [color="blue", label="suspend"];
- pending_query->deleted [color="red", label="failure"];
-
- suspended_query->pending_query [color="blue", label="resume"];
- suspended_query->deleted [color="blue", label="force-delete"];
-
- pending_user->pending_pickup [color="blue", label="accept"];
- pending_user->deleted [color="blue", label="force-delete"];
- pending_user->failed [label="expired"];
-
- pending_pickup->pending_kyc [label="kyc required"];
- pending_pickup->suspended_pickup [color="blue", label="suspend"];
- pending_pickup->done;
- pending_pickup->failed [color="red", label="failure"];
-
- suspended_pickup->pending_pickup [color="blue", label="resume"];
- suspended_pickup->failed [color="red", label="expired"];
- suspended_pickup->deleted [color="blue", label="force-delete"];
-
- pending_kyc->suspended_kyc [color="blue", label="suspend"];
-
- pending_kyc->pending_pickup [color="purple", label="long-poll:kyc"];
-
- suspended_kyc->pending_kyc [color="blue", label="resume"];
- suspended_kyc->deleted [color="blue", label="force-delete"];
-
- done->deleted [color="blue", label="delete"];
- failed->deleted [color="blue", label="delete"];
-
+
+ // subgraph {
+ // rank=same;
+ // pending_query; monolog_user;
+ // }
+
+ // subgraph {
+ // rank=same;
+ // done;
+ // //aborted_pickup; aborted_query;
+ // }
+
+ initial -> pending_query;
+
+
+ monolog_user -> pending_pickup [color=blue, label="OK"];
+
+ pending_query -> monolog_user [color=green];
+ //pending_query -> aborting_query;
+ //aborting_query -> aborted_query;
+
+ pending_pickup -> done [color=green];
+ //pending_pickup -> aborting_pickup;
+ //aborting_pickup -> aborted_pickup;
}
--
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.