# 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 ### Initialization * [InitWalletOp](#initwalletop) * [ShutdownOp](#shutdownop) * [HintApplicationResumedOp](#hintapplicationresumedop) * [SetWalletRunConfigOp](#setwalletrunconfigop) * [GetVersionOp](#getversionop) * [HintNetworkAvailabilityOp](#hintnetworkavailabilityop) ### Basic Wallet Information * [GetBalancesOp](#getbalancesop) * [GetBalancesDetailOp](#getbalancesdetailop) * [ConvertDepositAmountOp](#convertdepositamountop) * [GetMaxDepositAmountOp](#getmaxdepositamountop) * [GetMaxPeerPushDebitAmountOp](#getmaxpeerpushdebitamountop) ### Managing Transactions * [GetTransactionsOp](#gettransactionsop) * [GetTransactionsV2Op](#gettransactionsv2op) * [ListAssociatedRefreshesOp](#listassociatedrefreshesop) * [TestingGetSampleTransactionsOp](#testinggetsampletransactionsop) * [GetTransactionByIdOp](#gettransactionbyidop) * [RetryPendingNowOp](#retrypendingnowop) * [DeleteTransactionOp](#deletetransactionop) * [RetryTransactionOp](#retrytransactionop) * [AbortTransactionOp](#aborttransactionop) * [FailTransactionOp](#failtransactionop) * [SuspendTransactionOp](#suspendtransactionop) * [ResumeTransactionOp](#resumetransactionop) ### Withdrawals * [GetWithdrawalDetailsForAmountOp](#getwithdrawaldetailsforamountop) * [GetWithdrawalDetailsForUriOp](#getwithdrawaldetailsforuriop) * [PrepareBankIntegratedWithdrawalOp](#preparebankintegratedwithdrawalop) * [ConfirmWithdrawalOp](#confirmwithdrawalop) * [AcceptBankIntegratedWithdrawalOp](#acceptbankintegratedwithdrawalop) * [AcceptManualWithdrawalOp](#acceptmanualwithdrawalop) ### Merchant Payments * [PreparePayForUriOp](#preparepayforuriop) * [SharePaymentOp](#sharepaymentop) * [CheckPayForTemplateOp](#checkpayfortemplateop) * [PreparePayForTemplateOp](#preparepayfortemplateop) * [GetContractTermsDetailsOp](#getcontracttermsdetailsop) * [ConfirmPayOp](#confirmpayop) * [StartRefundQueryForUriOp](#startrefundqueryforuriop) * [StartRefundQueryOp](#startrefundqueryop) ### Global Currency management * [ListGlobalCurrencyAuditorsOp](#listglobalcurrencyauditorsop) * [ListGlobalCurrencyExchangesOp](#listglobalcurrencyexchangesop) * [AddGlobalCurrencyExchangeOp](#addglobalcurrencyexchangeop) * [AddGlobalCurrencyAuditorOp](#addglobalcurrencyauditorop) * [RemoveGlobalCurrencyExchangeOp](#removeglobalcurrencyexchangeop) * [RemoveGlobalCurrencyAuditorOp](#removeglobalcurrencyauditorop) ### Exchange Management * [ListExchangesOp](#listexchangesop) * [StartExchangeWalletKycOp](#startexchangewalletkycop) * [TestingWaitExchangeWalletKycOp](#testingwaitexchangewalletkycop) * [PrepareWithdrawExchangeOp](#preparewithdrawexchangeop) * [AddExchangeOp](#addexchangeop) * [UpdateExchangeEntryOp](#updateexchangeentryop) * [ListKnownBankAccountsOp](#listknownbankaccountsop) * [AddKnownBankAccountsOp](#addknownbankaccountsop) * [ForgetKnownBankAccountsOp](#forgetknownbankaccountsop) * [SetExchangeTosAcceptedOp](#setexchangetosacceptedop) * [SetExchangeTosForgottenOp](#setexchangetosforgottenop) * [GetExchangeTosOp](#getexchangetosop) * [GetDepositWireTypesForCurrencyOp](#getdepositwiretypesforcurrencyop) * [GetExchangeDetailedInfoOp](#getexchangedetailedinfoop) * [GetExchangeEntryByUrlOp](#getexchangeentrybyurlop) * [GetExchangeResourcesOp](#getexchangeresourcesop) * [DeleteExchangeOp](#deleteexchangeop) * [GetCurrencySpecificationOp](#getcurrencyspecificationop) ### Deposits * [GenerateDepositGroupTxIdOp](#generatedepositgrouptxidop) * [CreateDepositGroupOp](#createdepositgroupop) * [CheckDepositOp](#checkdepositop) * [PrepareDepositOp](#preparedepositop) ### Backups * [ExportBackupRecoveryOp](#exportbackuprecoveryop) * [ImportBackupRecoveryOp](#importbackuprecoveryop) * [RunBackupCycleOp](#runbackupcycleop) * [ExportBackupOp](#exportbackupop) * [AddBackupProviderOp](#addbackupproviderop) * [RemoveBackupProviderOp](#removebackupproviderop) * [GetBackupInfoOp](#getbackupinfoop) * [SetWalletDeviceIdOp](#setwalletdeviceidop) * [ListStoredBackupsOp](#liststoredbackupsop) * [CreateStoredBackupsOp](#createstoredbackupsop) * [RecoverStoredBackupsOp](#recoverstoredbackupsop) * [DeleteStoredBackupOp](#deletestoredbackupop) ### Peer Payments * [CheckPeerPushDebitOp](#checkpeerpushdebitop) * [InitiatePeerPushDebitOp](#initiatepeerpushdebitop) * [PreparePeerPushCreditOp](#preparepeerpushcreditop) * [ConfirmPeerPushCreditOp](#confirmpeerpushcreditop) * [CheckPeerPullCreditOp](#checkpeerpullcreditop) * [InitiatePeerPullCreditOp](#initiatepeerpullcreditop) * [PreparePeerPullDebitOp](#preparepeerpulldebitop) * [ConfirmPeerPullDebitOp](#confirmpeerpulldebitop) ### Data Validation * [ValidateIbanOp](#validateibanop) * [CanonicalizeBaseUrlOp](#canonicalizebaseurlop) * [GetQrCodesForPaytoOp](#getqrcodesforpaytoop) * [GetBankingChoicesForPaytoOp](#getbankingchoicesforpaytoop) ### 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) * [GetActiveTasksOp](#getactivetasksop) * [DumpCoinsOp](#dumpcoinsop) * [TestingSetTimetravelOp](#testingsettimetravelop) * [TestingWaitTransactionsFinalOp](#testingwaittransactionsfinalop) * [TestingWaitTasksDoneOp](#testingwaittasksdoneop) * [TestingWaitRefreshesFinalOp](#testingwaitrefreshesfinalop) * [TestingWaitTransactionStateOp](#testingwaittransactionstateop) * [TestingWaitExchangeStateOp](#testingwaitexchangestateop) * [TestingPingOp](#testingpingop) * [TestingGetReserveHistoryOp](#testinggetreservehistoryop) * [TestingResetAllRetriesOp](#testingresetallretriesop) * [TestingGetDenomStatsOp](#testinggetdenomstatsop) * [SetCoinSuspendedOp](#setcoinsuspendedop) * [ForceRefreshOp](#forcerefreshop) ## Operation Reference ### InitWalletOp ```typescript /** * Initialize wallet-core. * * Must be the first request made to wallet-core. */ export type InitWalletOp = { op: WalletApiOperation.InitWallet; request: InitRequest; response: InitResponse; }; // InitWallet = "initWallet" ``` ### ShutdownOp ```typescript export type ShutdownOp = { op: WalletApiOperation.Shutdown; request: EmptyObject; response: EmptyObject; }; // Shutdown = "shutdown" ``` ### HintApplicationResumedOp ```typescript /** * Give wallet-core a kick and restart all pending tasks. * Useful when the host application gets suspended and resumed, * and active network requests might have stalled. */ export type HintApplicationResumedOp = { op: WalletApiOperation.HintApplicationResumed; request: EmptyObject; response: EmptyObject; }; // HintApplicationResumed = "hintApplicationResumed" ``` ### SetWalletRunConfigOp ```typescript /** * Change the configuration of wallet-core. * * Currently an alias for the initWallet request. */ export type SetWalletRunConfigOp = { op: WalletApiOperation.SetWalletRunConfig; request: InitRequest; response: InitResponse; }; // SetWalletRunConfig = "setWalletRunConfig" ``` ### GetVersionOp ```typescript export type GetVersionOp = { op: WalletApiOperation.GetVersion; request: EmptyObject; response: WalletCoreVersion; }; // GetVersion = "getVersion" ``` ### HintNetworkAvailabilityOp ```typescript export type HintNetworkAvailabilityOp = { op: WalletApiOperation.HintNetworkAvailability; request: HintNetworkAvailabilityRequest; response: EmptyObject; }; // HintNetworkAvailability = "hintNetworkAvailability" ``` ```typescript export interface HintNetworkAvailabilityRequest { isNetworkAvailable: boolean; } ``` ### GetBalancesOp ```typescript /** * Get current wallet balance. */ export type GetBalancesOp = { op: WalletApiOperation.GetBalances; request: EmptyObject; response: BalancesResponse; }; // GetBalances = "getBalances" ``` ```typescript export interface BalancesResponse { balances: WalletBalance[]; } ``` ```typescript export interface WalletBalance { scopeInfo: ScopeInfo; available: AmountString; pendingIncoming: AmountString; pendingOutgoing: AmountString; /** * Does the balance for this currency have a pending * transaction? * * @deprecated use flags and pendingIncoming/pendingOutgoing instead */ hasPendingTransactions: boolean; /** * Is there a transaction that requires user input? * * @deprecated use flags instead */ requiresUserInput: boolean; flags: BalanceFlag[]; } ``` ```typescript export declare enum BalanceFlag { IncomingKyc = "incoming-kyc", IncomingAml = "incoming-aml", IncomingConfirmation = "incoming-confirmation", OutgoingKyc = "outgoing-kyc", } ``` ### GetBalancesDetailOp ```typescript export type GetBalancesDetailOp = { op: WalletApiOperation.GetBalanceDetail; request: GetBalanceDetailRequest; response: PaymentBalanceDetails; }; // GetBalanceDetail = "getBalanceDetail" ``` ```typescript export interface GetBalanceDetailRequest { currency: string; } ``` ```typescript export interface PaymentBalanceDetails { /** * 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 "receiver-acceptable" (see balance.ts for definition). */ balanceReceiverAcceptable: AmountJson; /** * Balance of type "receiver-depositable" (see balance.ts for definition). */ balanceReceiverDepositable: AmountJson; /** * Balance that's depositable with the exchange. * This balance is reduced by the exchange's debit restrictions * and wire fee configuration. */ balanceExchangeDepositable: AmountJson; /** * Estimated maximum amount that the wallet could pay for, under the assumption * that the merchant pays absolutely no fees. */ maxMerchantEffectiveDepositAmount: 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; } ``` ### ConvertDepositAmountOp ```typescript export type ConvertDepositAmountOp = { op: WalletApiOperation.ConvertDepositAmount; request: ConvertAmountRequest; response: AmountResponse; }; // ConvertDepositAmount = "convertDepositAmount" ``` ```typescript export interface ConvertAmountRequest { amount: AmountString; type: TransactionAmountMode; depositPaytoUri: PaytoString; } ``` ```typescript /** * How the amount should be interpreted in a transaction * Effective = how the balance is change * Raw = effective amount without fee * * Depending on the transaction, raw can be higher than effective */ export declare enum TransactionAmountMode { Effective = "effective", Raw = "raw", } ``` ```typescript export interface AmountResponse { effectiveAmount: AmountString; rawAmount: AmountString; } ``` ### GetMaxDepositAmountOp ```typescript export type GetMaxDepositAmountOp = { op: WalletApiOperation.GetMaxDepositAmount; request: GetMaxDepositAmountRequest; response: GetMaxDepositAmountResponse; }; // GetMaxDepositAmount = "getMaxDepositAmount" ``` ```typescript export interface GetMaxDepositAmountRequest { currency: string; depositPaytoUri?: string; } ``` ```typescript export interface GetMaxDepositAmountResponse { effectiveAmount: AmountString; rawAmount: AmountString; } ``` ### GetMaxPeerPushDebitAmountOp ```typescript export type GetMaxPeerPushDebitAmountOp = { op: WalletApiOperation.GetMaxPeerPushDebitAmount; request: GetMaxPeerPushDebitAmountRequest; response: GetMaxPeerPushDebitAmountResponse; }; // GetMaxPeerPushDebitAmount = "getMaxPeerPushDebitAmount" ``` ```typescript export interface GetMaxPeerPushDebitAmountRequest { currency: string; /** * Preferred exchange to use for the p2p payment. */ exchangeBaseUrl?: string; restrictScope?: ScopeInfo; } ``` ```typescript export interface GetMaxPeerPushDebitAmountResponse { effectiveAmount: AmountString; rawAmount: AmountString; exchangeBaseUrl?: 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 * * it will be removed in next release * * @deprecated use scopeInfo */ currency?: string; /** * return only transactions in the given scopeInfo */ scopeInfo?: ScopeInfo; /** * if present, results will be limited to transactions related to the given search string */ search?: string; /** * Sort order of the transaction items. * By default, items are sorted ascending by their * main timestamp. * * ascending: ascending by timestamp, but pending transactions first * descending: ascending by timestamp, but pending transactions first * stable-ascending: ascending by timestamp, with pending transactions amidst other transactions * (stable in the sense of: pending transactions don't jump around) */ sort?: "ascending" | "descending" | "stable-ascending"; /** * If true, include all refreshes in the transactions list. */ includeRefreshes?: boolean; filterByState?: TransactionStateFilter; } ``` ### GetTransactionsV2Op ```typescript export type GetTransactionsV2Op = { op: WalletApiOperation.GetTransactionsV2; request: GetTransactionsV2Request; response: TransactionsResponse; }; // GetTransactionsV2 = "getTransactionsV2" ``` ```typescript export interface GetTransactionsV2Request { /** * Return only transactions in the given currency. */ currency?: string; /** * Return only transactions in the given scopeInfo */ scopeInfo?: ScopeInfo; /** * If true, include all refreshes in the transactions list. */ includeRefreshes?: boolean; /** * Only return transactions before/after this offset. */ offsetTransactionId?: TransactionIdStr; /** * Only return transactions before/after the transaction with this * timestamp. * * Used as a fallback if the offsetTransactionId was deleted. */ offsetTimestamp?: TalerPreciseTimestamp; /** * Number of transactions to return. * * When the limit is positive, results are returned * in ascending order of their timestamp. If no offset is specified, * the result list begins with the first transaction. * If an offset is specified, transactions after the offset are returned. * * When the limit is negative, results are returned * in descending order of their timestamp. If no offset is specified, * the result list begins with with the last transaction. * If an offset is specified, transactions before the offset are returned. */ limit?: number; /** * Filter transactions by their state / state category. * * If not specified, all transactions are returned. */ filterByState?: "final" | "nonfinal" | "done"; } ``` ### ListAssociatedRefreshesOp ```typescript /** * List refresh transactions associated with another transaction. */ export type ListAssociatedRefreshesOp = { op: WalletApiOperation.ListAssociatedRefreshes; request: ListAssociatedRefreshesRequest; response: ListAssociatedRefreshesResponse; }; // ListAssociatedRefreshes = "listAssociatedRefreshes" ``` ```typescript export interface ListAssociatedRefreshesRequest { transactionId: string; } ``` ```typescript export interface ListAssociatedRefreshesResponse { transactionIds: string[]; } ``` ### TestingGetSampleTransactionsOp ```typescript /** * Get sample transactions. */ export type TestingGetSampleTransactionsOp = { op: WalletApiOperation.TestingGetSampleTransactions; request: EmptyObject; response: TransactionsResponse; }; // TestingGetSampleTransactions = "testingGetSampleTransactions" ``` ### 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: TransactionIdStr; } ``` ### RetryTransactionOp ```typescript /** * Immediately retry a transaction. */ export type RetryTransactionOp = { op: WalletApiOperation.RetryTransaction; request: RetryTransactionRequest; response: EmptyObject; }; // RetryTransaction = "retryTransaction" ``` ```typescript export interface RetryTransactionRequest { transactionId: TransactionIdStr; } ``` ### 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" ``` ### FailTransactionOp ```typescript /** * Cancel aborting a transaction * * For payment transactions, it puts the payment into an "aborting" state. */ export type FailTransactionOp = { op: WalletApiOperation.FailTransaction; request: FailTransactionRequest; response: EmptyObject; }; // FailTransaction = "failTransaction" ``` ```typescript export interface FailTransactionRequest { transactionId: TransactionIdStr; } ``` ### 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: WithdrawalDetailsForAmount; }; // GetWithdrawalDetailsForAmount = "getWithdrawalDetailsForAmount" ``` ```typescript export interface GetWithdrawalDetailsForAmountRequest { exchangeBaseUrl?: string; /** * Specify currency scope for the withdrawal. * * May only be used when exchangeBaseUrl is not specified. */ restrictScope?: ScopeInfo; amount: AmountString; restrictAge?: number; /** * ID provided by the client to cancel the request. * * If the same request is made again with the same clientCancellationId, * all previous requests are cancelled. * * The cancelled request will receive an error response with * an error code that indicates the cancellation. * * The cancellation is best-effort, responses might still arrive. */ clientCancellationId?: string; } ``` ```typescript export interface WithdrawalDetailsForAmount { /** * Exchange base URL for the withdrawal. */ exchangeBaseUrl: string; /** * Amount that the user will transfer to the exchange. */ amountRaw: AmountString; /** * Amount that will be added to the user's wallet balance. */ amountEffective: AmountString; /** * Number of coins that would be used for withdrawal. * * The UIs should warn if this number is too high (roughly at >100). */ numCoins: number; /** * Ways to pay the exchange, including accounts that require currency conversion. */ withdrawalAccountsList: WithdrawalExchangeAccountDetails[]; /** * If the exchange supports age-restricted coins it will return * the array of ages. */ ageRestrictionOptions?: number[]; /** * Scope info of the currency withdrawn. */ scopeInfo: ScopeInfo; /** * KYC soft limit. * * Withdrawals over that amount will require KYC. */ kycSoftLimit?: AmountString; /** * KYC soft limits. * * Withdrawals over that amount will be denied. */ kycHardLimit?: AmountString; /** * Ways to pay the exchange. * * @deprecated in favor of withdrawalAccountsList */ paytoUris: string[]; /** * Did the user accept the current version of the exchange's * terms of service? * * @deprecated the client should query the exchange entry instead */ tosAccepted: boolean; } ``` ### 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; /** * @deprecated not used */ restrictAge?: number; } ``` ### PrepareBankIntegratedWithdrawalOp ```typescript /** * Prepare a bank-integrated withdrawal operation. */ export type PrepareBankIntegratedWithdrawalOp = { op: WalletApiOperation.PrepareBankIntegratedWithdrawal; request: PrepareBankIntegratedWithdrawalRequest; response: PrepareBankIntegratedWithdrawalResponse; }; // PrepareBankIntegratedWithdrawal = "prepareBankIntegratedWithdrawal" ``` ```typescript export interface PrepareBankIntegratedWithdrawalRequest { talerWithdrawUri: string; } ``` ```typescript export interface PrepareBankIntegratedWithdrawalResponse { transactionId: TransactionIdStr; info: WithdrawUriInfoResponse; } ``` ### ConfirmWithdrawalOp ```typescript /** * Confirm a withdrawal transaction. */ export type ConfirmWithdrawalOp = { op: WalletApiOperation.ConfirmWithdrawal; request: ConfirmWithdrawalRequest; response: AcceptWithdrawalResponse; }; // ConfirmWithdrawal = "confirmWithdrawal" ``` ```typescript export interface ConfirmWithdrawalRequest { transactionId: string; exchangeBaseUrl: string; amount: AmountString; forcedDenomSel?: ForcedDenomSel; restrictAge?: number; } ``` ### AcceptBankIntegratedWithdrawalOp ```typescript /** * Accept a bank-integrated withdrawal. * * @deprecated in favor of prepare/confirm withdrawal. */ export type AcceptBankIntegratedWithdrawalOp = { op: WalletApiOperation.AcceptBankIntegratedWithdrawal; request: AcceptBankIntegratedWithdrawalRequest; response: AcceptWithdrawalResponse; }; // AcceptBankIntegratedWithdrawal = "acceptBankIntegratedWithdrawal" ``` ```typescript export interface AcceptBankIntegratedWithdrawalRequest { talerWithdrawUri: string; exchangeBaseUrl: string; forcedDenomSel?: ForcedDenomSel; /** * Amount to withdraw. * If the bank's withdrawal operation uses a fixed amount, * this field must either be left undefined or its value must match * the amount from the withdrawal operation. */ amount?: AmountString; restrictAge?: number; } ``` ### 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: AmountString; restrictAge?: number; /** * Instead of generating a fresh, random reserve key pair, * use the provided reserve private key. * * Use with caution. Usage of this field may be restricted * to developer mode. */ forceReservePriv?: EddsaPrivateKeyString; } ``` ```typescript export interface AcceptManualWithdrawalResult { /** * Payto URIs that can be used to fund the withdrawal. * * @deprecated in favor of withdrawalAccountsList */ exchangePaytoUris: string[]; /** * Public key of the newly created reserve. */ reservePub: string; withdrawalAccountsList: WithdrawalExchangeAccountDetails[]; transactionId: TransactionIdStr; } ``` ### 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; } ``` ### SharePaymentOp ```typescript export type SharePaymentOp = { op: WalletApiOperation.SharePayment; request: SharePaymentRequest; response: SharePaymentResult; }; // SharePayment = "sharePayment" ``` ```typescript export interface SharePaymentRequest { merchantBaseUrl: string; orderId: string; } ``` ```typescript export interface SharePaymentResult { privatePayUri: string; } ``` ### CheckPayForTemplateOp ```typescript export type CheckPayForTemplateOp = { op: WalletApiOperation.CheckPayForTemplate; request: CheckPayTemplateRequest; response: CheckPayTemplateReponse; }; // CheckPayForTemplate = "checkPayForTemplate" ``` ```typescript export interface CheckPayTemplateRequest { talerPayTemplateUri: string; } ``` ```typescript export type CheckPayTemplateReponse = { templateDetails: TalerMerchantApi.WalletTemplateDetails; supportedCurrencies: string[]; }; ``` ```typescript export interface WalletTemplateDetails { template_contract: TemplateContractDetails; editable_defaults?: TemplateContractDetailsDefaults; } ``` ```typescript export interface TemplateContractDetails { summary?: string; currency?: string; amount?: AmountString; minimum_age: Integer; pay_duration: RelativeTime; } ``` ```typescript export interface TemplateContractDetailsDefaults { summary?: string; currency?: string; /** * Amount *or* a plain currency string. */ amount?: 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?: TemplateParams; } ``` ```typescript export type TemplateParams = { amount?: string; summary?: string; }; ``` ### GetContractTermsDetailsOp ```typescript export type GetContractTermsDetailsOp = { op: WalletApiOperation.GetContractTermsDetails; request: GetContractTermsDetailsRequest; response: WalletContractData; }; // GetContractTermsDetails = "getContractTermsDetails" ``` ```typescript export interface GetContractTermsDetailsRequest { transactionId: string; } ``` ```typescript /** * Data extracted from the contract terms that is relevant for payment * processing in the wallet. */ export interface WalletContractData { /** * 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; summaryI18n: | { [lang_tag: string]: string; } | undefined; autoRefund: TalerProtocolDuration | undefined; payDeadline: TalerProtocolTimestamp; refundDeadline: TalerProtocolTimestamp; allowedExchanges: AllowedExchangeInfo[]; timestamp: TalerProtocolTimestamp; wireMethod: string; wireInfoHash: string; maxDepositFee: AmountString; minimumAge?: number; } ``` ```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 { transactionId: TransactionIdStr; sessionId?: string; forcedCoinSel?: ForcedCoinSel; } ``` ```typescript export type ConfirmPayResult = ConfirmPayResultDone | ConfirmPayResultPending; ``` ```typescript /** * Result for confirmPay */ export interface ConfirmPayResultDone { type: ConfirmPayResultType.Done; contractTerms: MerchantContractTerms; transactionId: TransactionIdStr; } ``` ```typescript export interface ConfirmPayResultPending { type: ConfirmPayResultType.Pending; transactionId: TransactionIdStr; lastError: TalerErrorDetail | undefined; } ``` ### StartRefundQueryForUriOp ```typescript /** * Check for a refund based on a taler://refund URI. */ export type StartRefundQueryForUriOp = { op: WalletApiOperation.StartRefundQueryForUri; request: PrepareRefundRequest; response: StartRefundQueryForUriResponse; }; // StartRefundQueryForUri = "startRefundQueryForUri" ``` ```typescript export interface PrepareRefundRequest { talerRefundUri: string; } ``` ```typescript export interface StartRefundQueryForUriResponse { /** * Transaction id of the *payment* where the refund query was started. */ transactionId: TransactionIdStr; } ``` ### StartRefundQueryOp ```typescript export type StartRefundQueryOp = { op: WalletApiOperation.StartRefundQuery; request: StartRefundQueryRequest; response: EmptyObject; }; // StartRefundQuery = "startRefundQuery" ``` ```typescript export interface StartRefundQueryRequest { transactionId: TransactionIdStr; } ``` ### ListGlobalCurrencyAuditorsOp ```typescript export type ListGlobalCurrencyAuditorsOp = { op: WalletApiOperation.ListGlobalCurrencyAuditors; request: EmptyObject; response: ListGlobalCurrencyAuditorsResponse; }; // ListGlobalCurrencyAuditors = "listGlobalCurrencyAuditors" ``` ```typescript export interface ListGlobalCurrencyAuditorsResponse { auditors: { currency: string; auditorBaseUrl: string; auditorPub: string; }[]; } ``` ### ListGlobalCurrencyExchangesOp ```typescript export type ListGlobalCurrencyExchangesOp = { op: WalletApiOperation.ListGlobalCurrencyExchanges; request: EmptyObject; response: ListGlobalCurrencyExchangesResponse; }; // ListGlobalCurrencyExchanges = "listGlobalCurrencyExchanges" ``` ```typescript export interface ListGlobalCurrencyExchangesResponse { exchanges: { currency: string; exchangeBaseUrl: string; exchangeMasterPub: string; }[]; } ``` ### AddGlobalCurrencyExchangeOp ```typescript export type AddGlobalCurrencyExchangeOp = { op: WalletApiOperation.AddGlobalCurrencyExchange; request: AddGlobalCurrencyExchangeRequest; response: EmptyObject; }; // AddGlobalCurrencyExchange = "addGlobalCurrencyExchange" ``` ```typescript export interface AddGlobalCurrencyExchangeRequest { currency: string; exchangeBaseUrl: string; exchangeMasterPub: string; } ``` ### AddGlobalCurrencyAuditorOp ```typescript export type AddGlobalCurrencyAuditorOp = { op: WalletApiOperation.AddGlobalCurrencyAuditor; request: AddGlobalCurrencyAuditorRequest; response: EmptyObject; }; // AddGlobalCurrencyAuditor = "addGlobalCurrencyAuditor" ``` ```typescript export interface AddGlobalCurrencyAuditorRequest { currency: string; auditorBaseUrl: string; auditorPub: string; } ``` ### RemoveGlobalCurrencyExchangeOp ```typescript export type RemoveGlobalCurrencyExchangeOp = { op: WalletApiOperation.RemoveGlobalCurrencyExchange; request: RemoveGlobalCurrencyExchangeRequest; response: EmptyObject; }; // RemoveGlobalCurrencyExchange = "removeGlobalCurrencyExchange" ``` ```typescript export interface RemoveGlobalCurrencyExchangeRequest { currency: string; exchangeBaseUrl: string; exchangeMasterPub: string; } ``` ### RemoveGlobalCurrencyAuditorOp ```typescript export type RemoveGlobalCurrencyAuditorOp = { op: WalletApiOperation.RemoveGlobalCurrencyAuditor; request: RemoveGlobalCurrencyAuditorRequest; response: EmptyObject; }; // RemoveGlobalCurrencyAuditor = "removeGlobalCurrencyAuditor" ``` ```typescript export interface RemoveGlobalCurrencyAuditorRequest { currency: string; auditorBaseUrl: string; auditorPub: string; } ``` ### ListExchangesOp ```typescript /** * List exchanges known to the wallet. */ export type ListExchangesOp = { op: WalletApiOperation.ListExchanges; request: ListExchangesRequest; response: ExchangesListResponse; }; // ListExchanges = "listExchanges" ``` ```typescript export interface ListExchangesRequest { /** * Filter results to only include exchanges in the given scope. */ filterByScope?: ScopeInfo; filterByExchangeEntryStatus?: ExchangeEntryStatus; } ``` ```typescript export interface ExchangesListResponse { exchanges: ExchangeListItem[]; } ``` ### StartExchangeWalletKycOp ```typescript export type StartExchangeWalletKycOp = { op: WalletApiOperation.StartExchangeWalletKyc; request: StartExchangeWalletKycRequest; response: EmptyObject; }; // StartExchangeWalletKyc = "startExchangeWalletKyc" ``` ```typescript export interface StartExchangeWalletKycRequest { exchangeBaseUrl: string; amount: AmountString; } ``` ### TestingWaitExchangeWalletKycOp ```typescript export type TestingWaitExchangeWalletKycOp = { op: WalletApiOperation.TestingWaitExchangeWalletKyc; request: TestingWaitWalletKycRequest; response: EmptyObject; }; // TestingWaitExchangeWalletKyc = "testingWaitWalletKyc" ``` ```typescript export interface TestingWaitWalletKycRequest { exchangeBaseUrl: string; amount: AmountString; /** * Do we wait for the KYC to be passed (true), * or do we already return if legitimization is * required (false). */ passed: boolean; } ``` ### PrepareWithdrawExchangeOp ```typescript /** * Prepare for withdrawing via a taler://withdraw-exchange URI. */ export type PrepareWithdrawExchangeOp = { op: WalletApiOperation.PrepareWithdrawExchange; request: PrepareWithdrawExchangeRequest; response: PrepareWithdrawExchangeResponse; }; // PrepareWithdrawExchange = "prepareWithdrawExchange" ``` ```typescript export interface PrepareWithdrawExchangeRequest { /** * A taler://withdraw-exchange URI. */ talerUri: string; } ``` ```typescript export interface PrepareWithdrawExchangeResponse { /** * Base URL of the exchange that already existed * or was ephemerally added as an exchange entry to * the wallet. */ exchangeBaseUrl: string; /** * Amount from the taler://withdraw-exchange URI. * Only present if specified in the URI. */ amount?: AmountString; } ``` ### AddExchangeOp ```typescript /** * Add / force-update an exchange. */ export type AddExchangeOp = { op: WalletApiOperation.AddExchange; request: AddExchangeRequest; response: EmptyObject; }; // AddExchange = "addExchange" ``` ### UpdateExchangeEntryOp ```typescript /** * Update an exchange entry. */ export type UpdateExchangeEntryOp = { op: WalletApiOperation.UpdateExchangeEntry; request: UpdateExchangeEntryRequest; response: EmptyObject; }; // UpdateExchangeEntry = "updateExchangeEntry" ``` ```typescript export interface UpdateExchangeEntryRequest { exchangeBaseUrl: string; force?: boolean; } ``` ### 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: PaytoType | string; targetPath: string; params: { [name: string]: string; }; } ``` ```typescript export type PaytoType = "iban" | "bitcoin" | "x-taler-bank"; ``` ```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"; address: string; segwitAddrs: Array; } ``` ### 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" ``` ### SetExchangeTosForgottenOp ```typescript /** * Accept a particular version of the exchange terms of service. */ export type SetExchangeTosForgottenOp = { op: WalletApiOperation.SetExchangeTosForgotten; request: AcceptExchangeTosRequest; response: EmptyObject; }; // SetExchangeTosForgotten = "setExchangeTosForgotten" ``` ### 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[]; acceptLanguage?: 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; /** * Language of the returned content. * * If missing, language is unknown. */ contentLanguage: string | undefined; /** * Available languages as advertised by the exchange. */ tosAvailableLanguages: string[]; tosStatus: ExchangeTosStatus; } ``` ### GetDepositWireTypesForCurrencyOp ```typescript /** * Get wire types that can be used for a deposit operation * with the provided currency. */ export type GetDepositWireTypesForCurrencyOp = { op: WalletApiOperation.GetDepositWireTypesForCurrency; request: GetDepositWireTypesForCurrencyRequest; response: GetDepositWireTypesForCurrencyResponse; }; // GetDepositWireTypesForCurrency = "getDepositWireTypesForCurrency" ``` ```typescript export interface GetDepositWireTypesForCurrencyRequest { currency: string; /** * Optional scope info to further restrict the result. * Currency must match the currency field. */ scopeInfo?: ScopeInfo; } ``` ```typescript /** * Response with wire types that are supported for a deposit. * * In the future, we might surface more information here, such as debit restrictions * by the exchange, which then can be shown by UIs to the user before they * enter their payment information. */ export interface GetDepositWireTypesForCurrencyResponse { /** * @deprecated, use wireTypeDetails instead. */ wireTypes: string[]; /** * Details for each wire type. */ wireTypeDetails: WireTypeDetails[]; } ``` ```typescript export interface WireTypeDetails { paymentTargetType: string; /** * Allowed hostnames for the deposit payto URI. * Only applicable to x-taler-bank. */ talerBankHostnames?: string[]; } ``` ### 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[]; auditors: ExchangeAuditor[]; wireInfo: WireInfo; denomFees: DenomOperationMap; transferFees: Record; globalFees: FeeDescription[]; } ``` ```typescript /** * Auditor information as given by the exchange in /keys. */ export interface ExchangeAuditor { /** * Auditor's public key. */ auditor_pub: string; /** * Base URL of the auditor. */ auditor_url: string; /** * List of signatures for denominations by the auditor. */ denomination_keys: AuditorDenomSig[]; } ``` ```typescript /** * Signature by the auditor that a particular denomination key is audited. */ export interface AuditorDenomSig { /** * Denomination public key's hash. */ denom_pub_h: string; /** * The signature. */ auditor_sig: string; } ``` ```typescript export interface WireInfo { feesForType: WireFeeMap; accounts: ExchangeWireAccount[]; } ``` ```typescript export type WireFeeMap = { [wireMethod: string]: WireFee[]; }; ``` ```typescript /** * Wire fee for one wire method */ export interface WireFee { /** * Fee for wire transfers. */ wireFee: AmountString; /** * Fees to close and refund a reserve. */ closingFee: AmountString; /** * Start date of the fee. */ startStamp: TalerProtocolTimestamp; /** * End date of the fee. */ endStamp: TalerProtocolTimestamp; /** * Signature made by the exchange master key. */ sig: string; } ``` ```typescript export interface ExchangeWireAccount { payto_uri: string; conversion_url?: string; credit_restrictions: AccountRestriction[]; debit_restrictions: AccountRestriction[]; master_sig: EddsaSignatureString; bank_label?: string; priority?: number; } ``` ```typescript export type DenomOperationMap = { [op in DenomOperation]: T; }; ``` ```typescript export type DenomOperation = "deposit" | "withdraw" | "refresh" | "refund"; ``` ```typescript export interface FeeDescription { group: string; from: AbsoluteTime; until: AbsoluteTime; fee?: AmountString; } ``` ### GetExchangeEntryByUrlOp ```typescript /** * Get the current terms of a service of an exchange. */ export type GetExchangeEntryByUrlOp = { op: WalletApiOperation.GetExchangeEntryByUrl; request: GetExchangeEntryByUrlRequest; response: GetExchangeEntryByUrlResponse; }; // GetExchangeEntryByUrl = "getExchangeEntryByUrl" ``` ```typescript export interface GetExchangeEntryByUrlRequest { exchangeBaseUrl: string; } ``` ### GetExchangeResourcesOp ```typescript /** * Get resources associated with an exchange. */ export type GetExchangeResourcesOp = { op: WalletApiOperation.GetExchangeResources; request: GetExchangeResourcesRequest; response: GetExchangeResourcesResponse; }; // GetExchangeResources = "getExchangeResources" ``` ```typescript export interface GetExchangeResourcesRequest { exchangeBaseUrl: string; } ``` ```typescript export interface GetExchangeResourcesResponse { hasResources: boolean; } ``` ### DeleteExchangeOp ```typescript /** * Get resources associated with an exchange. */ export type DeleteExchangeOp = { op: WalletApiOperation.GetExchangeResources; request: DeleteExchangeRequest; response: EmptyObject; }; // GetExchangeResources = "getExchangeResources" ``` ```typescript export interface DeleteExchangeRequest { exchangeBaseUrl: string; purge?: boolean; } ``` ### GetCurrencySpecificationOp ```typescript export type GetCurrencySpecificationOp = { op: WalletApiOperation.GetCurrencySpecification; request: GetCurrencySpecificationRequest; response: GetCurrencySpecificationResponse; }; // GetCurrencySpecification = "getCurrencySpecification" ``` ```typescript export interface GetCurrencySpecificationRequest { scope: ScopeInfo; } ``` ```typescript export interface GetCurrencySpecificationResponse { currencySpecification: CurrencySpecification; } ``` ### 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: TransactionIdStr; } ``` ### 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?: TransactionIdStr; depositPaytoUri: string; amount: AmountString; } ``` ```typescript export interface CreateDepositGroupResponse { depositGroupId: string; transactionId: TransactionIdStr; } ``` ### CheckDepositOp ```typescript export type CheckDepositOp = { op: WalletApiOperation.CheckDeposit; request: CheckDepositRequest; response: CheckDepositResponse; }; // CheckDeposit = "checkDeposit" ``` ### PrepareDepositOp ```typescript /** * @deprecated use CheckDepositOp instead */ export type PrepareDepositOp = { op: WalletApiOperation.PrepareDeposit; request: CheckDepositRequest; response: CheckDepositResponse; }; // PrepareDeposit = "prepareDeposit" ``` ### 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; } ``` ### 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?: TalerPreciseTimestamp; lastAttemptedBackupTimestamp?: TalerPreciseTimestamp; 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; } ``` ### ListStoredBackupsOp ```typescript export type ListStoredBackupsOp = { op: WalletApiOperation.ListStoredBackups; request: EmptyObject; response: StoredBackupList; }; // ListStoredBackups = "listStoredBackups" ``` ```typescript export interface StoredBackupList { storedBackups: { name: string; }[]; } ``` ### CreateStoredBackupsOp ```typescript export type CreateStoredBackupsOp = { op: WalletApiOperation.CreateStoredBackup; request: EmptyObject; response: CreateStoredBackupResponse; }; // CreateStoredBackup = "createStoredBackup" ``` ```typescript export interface CreateStoredBackupResponse { name: string; } ``` ### RecoverStoredBackupsOp ```typescript export type RecoverStoredBackupsOp = { op: WalletApiOperation.RecoverStoredBackup; request: RecoverStoredBackupRequest; response: EmptyObject; }; // RecoverStoredBackup = "recoverStoredBackup" ``` ```typescript export interface RecoverStoredBackupRequest { name: string; } ``` ### DeleteStoredBackupOp ```typescript export type DeleteStoredBackupOp = { op: WalletApiOperation.DeleteStoredBackup; request: DeleteStoredBackupRequest; response: EmptyObject; }; // DeleteStoredBackup = "deleteStoredBackup" ``` ```typescript export interface DeleteStoredBackupRequest { name: string; } ``` ### 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; /** * Restrict the scope of funds that can be spent via the given * scope info. */ restrictScope?: ScopeInfo; /** * ID provided by the client to cancel the request. * * If the same request is made again with the same clientCancellationId, * all previous requests are cancelled. * * The cancelled request will receive an error response with * an error code that indicates the cancellation. * * The cancellation is best-effort, responses might still arrive. */ clientCancellationId?: string; } ``` ```typescript export interface CheckPeerPushDebitResponse { amountRaw: AmountString; amountEffective: AmountString; /** * Exchange base URL. */ exchangeBaseUrl: string; /** * Maximum expiration date, based on how close the coins * used for the payment are to expiry. * * The value is based on when the wallet would typically * automatically refresh the coins on its own, leaving enough * time to get a refund for the push payment and refresh the * coin. */ maxExpirationDate: TalerProtocolTimestamp; } ``` ### InitiatePeerPushDebitOp ```typescript /** * Initiate an outgoing peer push payment. */ export type InitiatePeerPushDebitOp = { op: WalletApiOperation.InitiatePeerPushDebit; request: InitiatePeerPushDebitRequest; response: InitiatePeerPushDebitResponse; }; // InitiatePeerPushDebit = "initiatePeerPushDebit" ``` ```typescript export interface InitiatePeerPushDebitRequest { exchangeBaseUrl?: string; /** * Restrict the scope of funds that can be spent via the given * scope info. */ restrictScope?: ScopeInfo; partialContractTerms: PeerContractTerms; } ``` ```typescript export interface InitiatePeerPushDebitResponse { exchangeBaseUrl: string; pursePub: string; mergePriv: string; contractPriv: string; transactionId: TransactionIdStr; } ``` ### PreparePeerPushCreditOp ```typescript /** * Check an incoming peer push payment. */ export type PreparePeerPushCreditOp = { op: WalletApiOperation.PreparePeerPushCredit; request: PreparePeerPushCreditRequest; response: PreparePeerPushCreditResponse; }; // PreparePeerPushCredit = "preparePeerPushCredit" ``` ```typescript export interface PreparePeerPushCreditRequest { talerUri: string; } ``` ```typescript export interface PreparePeerPushCreditResponse { contractTerms: PeerContractTerms; amountRaw: AmountString; amountEffective: AmountString; transactionId: TransactionIdStr; exchangeBaseUrl: string; scopeInfo: ScopeInfo; /** * @deprecated */ amount: AmountString; } ``` ### ConfirmPeerPushCreditOp ```typescript /** * Accept an incoming peer push payment. */ export type ConfirmPeerPushCreditOp = { op: WalletApiOperation.ConfirmPeerPushCredit; request: ConfirmPeerPushCreditRequest; response: AcceptPeerPushPaymentResponse; }; // ConfirmPeerPushCredit = "confirmPeerPushCredit" ``` ```typescript export interface ConfirmPeerPushCreditRequest { transactionId: string; } ``` ```typescript export interface AcceptPeerPushPaymentResponse { transactionId: TransactionIdStr; } ``` ### 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 { /** * Require using this particular exchange for this operation. */ exchangeBaseUrl?: string; restrictScope?: ScopeInfo; amount: AmountString; /** * ID provided by the client to cancel the request. * * If the same request is made again with the same clientCancellationId, * all previous requests are cancelled. * * The cancelled request will receive an error response with * an error code that indicates the cancellation. * * The cancellation is best-effort, responses might still arrive. */ clientCancellationId?: string; } ``` ```typescript export interface CheckPeerPullCreditResponse { exchangeBaseUrl: string; amountRaw: AmountString; amountEffective: AmountString; /** * Number of coins that will be used, * can be used by the UI to warn if excessively large. */ numCoins: number; } ``` ### 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. * * @deprecated since it's not necessarily valid yet until the tx is in the right state */ talerUri: string; transactionId: TransactionIdStr; } ``` ### 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; amountRaw: AmountString; amountEffective: AmountString; transactionId: TransactionIdStr; exchangeBaseUrl: string; scopeInfo: ScopeInfo; /** * @deprecated Redundant field with bad name, will be removed soon. */ amount: AmountString; } ``` ### ConfirmPeerPullDebitOp ```typescript /** * Accept an incoming peer pull payment (i.e. pay the other party). */ export type ConfirmPeerPullDebitOp = { op: WalletApiOperation.ConfirmPeerPullDebit; request: ConfirmPeerPullDebitRequest; response: AcceptPeerPullPaymentResponse; }; // ConfirmPeerPullDebit = "confirmPeerPullDebit" ``` ```typescript export interface ConfirmPeerPullDebitRequest { transactionId: TransactionIdStr; } ``` ```typescript export interface AcceptPeerPullPaymentResponse { transactionId: TransactionIdStr; } ``` ### 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; } ``` ### CanonicalizeBaseUrlOp ```typescript export type CanonicalizeBaseUrlOp = { op: WalletApiOperation.CanonicalizeBaseUrl; request: CanonicalizeBaseUrlRequest; response: CanonicalizeBaseUrlResponse; }; // CanonicalizeBaseUrl = "canonicalizeBaseUrl" ``` ```typescript export interface CanonicalizeBaseUrlRequest { url: string; } ``` ```typescript export interface CanonicalizeBaseUrlResponse { url: string; } ``` ### GetQrCodesForPaytoOp ```typescript export type GetQrCodesForPaytoOp = { op: WalletApiOperation.GetQrCodesForPayto; request: GetQrCodesForPaytoRequest; response: GetQrCodesForPaytoResponse; }; // GetQrCodesForPayto = "getQrCodesForPayto" ``` ```typescript export interface GetQrCodesForPaytoRequest { paytoUri: string; } ``` ```typescript export interface GetQrCodesForPaytoResponse { codes: QrCodeSpec[]; } ``` ```typescript /** * Specification of a QR code that includes payment information. */ export interface QrCodeSpec { /** * Type of the QR code. * * Depending on the type, different visual styles * might be applied. */ type: string; /** * Content of the QR code that should be rendered. */ qrContent: string; } ``` ### GetBankingChoicesForPaytoOp ```typescript export type GetBankingChoicesForPaytoOp = { op: WalletApiOperation.GetBankingChoicesForPayto; request: GetBankingChoicesForPaytoRequest; response: GetBankingChoicesForPaytoResponse; }; // GetBankingChoicesForPayto = "getBankingChoicesForPayto" ``` ```typescript export interface GetBankingChoicesForPaytoRequest { paytoUri: string; } ``` ```typescript export interface GetBankingChoicesForPaytoResponse { choices: BankingChoiceSpec[]; } ``` ```typescript export interface BankingChoiceSpec { label: string; type: "link"; uri: string; } ``` ### 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: ImportDbRequest; response: EmptyObject; }; // ImportDb = "importDb" ``` ```typescript export interface ImportDbRequest { dump: any; } ``` ### 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" ``` ```typescript export interface IntegrationTestArgs { exchangeBaseUrl: string; corebankApiBaseUrl: string; merchantBaseUrl: string; merchantAuthToken?: string; amountToWithdraw: AmountString; amountToSpend: AmountString; } ``` ### RunIntegrationTestV2Op ```typescript /** * Run a simple integration test on a test deployment * of the exchange and merchant. */ export type RunIntegrationTestV2Op = { op: WalletApiOperation.RunIntegrationTestV2; request: IntegrationTestV2Args; response: EmptyObject; }; // RunIntegrationTestV2 = "runIntegrationTestV2" ``` ```typescript export interface IntegrationTestV2Args { exchangeBaseUrl: string; corebankApiBaseUrl: string; merchantBaseUrl: string; merchantAuthToken?: string; } ``` ### 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: AmountString; /** * Corebank API base URL. */ corebankApiBaseUrl: 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: AmountString; summary: string; forcedCoinSel?: ForcedCoinSel; } ``` ```typescript export interface TestPayResult { /** * Number of coins used for the payment. */ numCoins: number; } ``` ### GetActiveTasksOp ```typescript export type GetActiveTasksOp = { op: WalletApiOperation.GetActiveTasks; request: EmptyObject; response: GetActiveTasksResponse; }; // GetActiveTasks = "getActiveTasks" ``` ```typescript export interface GetActiveTasksResponse { tasks: ActiveTask[]; } ``` ```typescript export interface ActiveTask { taskId: string; transaction: TransactionIdStr | undefined; firstTry: AbsoluteTime | undefined; nextTry: AbsoluteTime | undefined; retryCounter: number | undefined; lastError: TalerErrorDetail | undefined; } ``` ### 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. */ denomPub: DenominationPubKey; /** * Hash of denom_pub. */ denomPubHash: string; /** * Value of the denomination (without any fees). */ denomValue: string; /** * Public key of the coin. */ coinPub: string; /** * Base URL of the exchange for the coin. */ exchangeBaseUrl: string; /** * Public key of the parent coin. * Only present if this coin was obtained via refreshing. */ refreshParentCoinPub: string | undefined; /** * Public key of the reserve for this coin. * Only present if this coin was obtained via refreshing. */ withdrawalReservePub: string | undefined; /** * Status of the coin. */ coinStatus: CoinStatus; /** * Information about the age restriction */ ageCommitmentProof: AgeCommitmentProof | undefined; history: WalletCoinHistoryItem[]; }>; } ``` ```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", /** * Coin was lost as the denomination is not usable anymore. */ DenomLoss = "denom-loss", /** * 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; ``` ```typescript export type FlavorP = 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 >; ``` ```typescript export type WalletCoinHistoryItem = | { type: "withdraw"; transactionId: TransactionIdStr; } | { type: "spend"; transactionId: TransactionIdStr; amount: AmountString; } | { type: "refresh"; transactionId: TransactionIdStr; amount: AmountString; } | { type: "recoup"; transactionId: TransactionIdStr; amount: AmountString; } | { type: "refund"; transactionId: TransactionIdStr; amount: AmountString; }; ``` ### TestingSetTimetravelOp ```typescript /** * Add an offset to the wallet's internal time. */ export type TestingSetTimetravelOp = { op: WalletApiOperation.TestingSetTimetravel; request: TestingSetTimetravelRequest; response: EmptyObject; }; // TestingSetTimetravel = "testingSetTimetravel" ``` ```typescript export interface TestingSetTimetravelRequest { offsetMs: number; } ``` ### TestingWaitTransactionsFinalOp ```typescript /** * Wait until all transactions are in a final state. */ export type TestingWaitTransactionsFinalOp = { op: WalletApiOperation.TestingWaitTransactionsFinal; request: EmptyObject; response: EmptyObject; }; // TestingWaitTransactionsFinal = "testingWaitTransactionsFinal" ``` ### TestingWaitTasksDoneOp ```typescript /** * Wait until all transactions are in a final state. */ export type TestingWaitTasksDoneOp = { op: WalletApiOperation.TestingWaitTasksDone; request: EmptyObject; response: EmptyObject; }; // TestingWaitTasksDone = "testingWaitTasksDone" ``` ### TestingWaitRefreshesFinalOp ```typescript /** * Wait until all refresh transactions are in a final state. */ export type TestingWaitRefreshesFinalOp = { op: WalletApiOperation.TestingWaitRefreshesFinal; request: EmptyObject; response: EmptyObject; }; // TestingWaitRefreshesFinal = "testingWaitRefreshesFinal" ``` ### TestingWaitTransactionStateOp ```typescript /** * Wait until a transaction is in a particular state. */ export type TestingWaitTransactionStateOp = { op: WalletApiOperation.TestingWaitTransactionState; request: TestingWaitTransactionRequest; response: EmptyObject; }; // TestingWaitTransactionState = "testingWaitTransactionState" ``` ```typescript export interface TestingWaitTransactionRequest { transactionId: TransactionIdStr; txState: TransactionState | TransactionState[]; } ``` ### TestingWaitExchangeStateOp ```typescript /** * Wait until an exchange entry is in a particular state. */ export type TestingWaitExchangeStateOp = { op: WalletApiOperation.TestingWaitTransactionState; request: TestingWaitExchangeStateRequest; response: EmptyObject; }; // TestingWaitTransactionState = "testingWaitTransactionState" ``` ```typescript export interface TestingWaitExchangeStateRequest { exchangeBaseUrl: string; walletKycStatus?: ExchangeWalletKycStatus; } ``` ### TestingPingOp ```typescript export type TestingPingOp = { op: WalletApiOperation.TestingPing; request: EmptyObject; response: EmptyObject; }; // TestingPing = "testingPing" ``` ### TestingGetReserveHistoryOp ```typescript export type TestingGetReserveHistoryOp = { op: WalletApiOperation.TestingGetReserveHistory; request: TestingGetReserveHistoryRequest; response: any; }; // TestingGetReserveHistory = "testingGetReserveHistory" ``` ```typescript export interface TestingGetReserveHistoryRequest { reservePub: string; exchangeBaseUrl: string; } ``` ### TestingResetAllRetriesOp ```typescript /** * Reset all task/transaction retries, * resulting in immediate re-try of all operations. */ export type TestingResetAllRetriesOp = { op: WalletApiOperation.TestingResetAllRetries; request: EmptyObject; response: EmptyObject; }; // TestingResetAllRetries = "testingResetAllRetries" ``` ### TestingGetDenomStatsOp ```typescript /** * Get stats about an exchange denomination. */ export type TestingGetDenomStatsOp = { op: WalletApiOperation.TestingGetDenomStats; request: TestingGetDenomStatsRequest; response: TestingGetDenomStatsResponse; }; // TestingGetDenomStats = "testingGetDenomStats" ``` ```typescript export interface TestingGetDenomStatsRequest { exchangeBaseUrl: string; } ``` ```typescript export interface TestingGetDenomStatsResponse { numKnown: number; numOffered: number; numLost: number; } ``` ### 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 { refreshCoinSpecs: RefreshCoinSpec[]; } ``` ```typescript export interface RefreshCoinSpec { coinPub: string; amount?: AmountString; } ``` ## Common Declarations ```typescript export interface InitRequest { config?: PartialWalletRunConfig; } ``` ```typescript export interface PartialWalletRunConfig { builtin?: Partial; testing?: Partial; features?: Partial; lazyTaskLoop?: Partial; } ``` ```typescript export interface WalletRunConfig { /** * Initialization values useful for a complete startup. * * These are values may be overridden by different wallets */ builtin: { exchanges: BuiltinExchange[]; }; /** * Unsafe options which it should only be used to create * testing environment. */ testing: { /** * Allow withdrawal of denominations even though they are about to expire. */ denomselAllowLate: boolean; devModeActive: boolean; insecureTrustExchange: boolean; preventThrottling: boolean; skipDefaults: boolean; emitObservabilityEvents?: boolean; }; /** * Configurations values that may be safe to show to the user */ features: { allowHttp: boolean; }; /** * Start processing tasks only when explicitly required, even after * init has been called. * * Useful when the wallet is started to make single read-only request, * as otherwise wallet-core starts making network request and process * unrelated pending tasks. */ lazyTaskLoop: boolean; } ``` ```typescript export interface BuiltinExchange { exchangeBaseUrl: string; currencyHint: string; } ``` ```typescript export interface InitResponse { versionInfo: WalletCoreVersion; } ``` ```typescript export interface WalletCoreVersion { implementationSemver: string; implementationGitHash: string; /** * Wallet-core protocol version supported by this implementation * of the API ("server" version). */ version: string; exchange: string; merchant: string; bankIntegrationApiRange: string; bankConversionApiRange: string; corebankApiRange: string; /** * @deprecated as bank was split into multiple APIs with separate versioning */ bank: string; /** * @deprecated */ hash: string | undefined; /** * @deprecated will be removed */ devMode: boolean; } ``` ```typescript export type EmptyObject = Record; ``` ```typescript export type ScopeInfo = ScopeInfoGlobal | ScopeInfoExchange | ScopeInfoAuditor; ``` ```typescript export type ScopeInfoGlobal = { type: ScopeType.Global; currency: string; }; ``` ```typescript export type ScopeInfoExchange = { type: ScopeType.Exchange; currency: string; url: string; }; ``` ```typescript export interface Exchange { url: string; priority: Integer; master_pub: EddsaPublicKey; } ``` ```typescript export type ScopeInfoAuditor = { type: ScopeType.Auditor; currency: string; url: string; }; ``` ```typescript export type AmountString = | (string & { [__amount_str]: true; }) | LitAmountString; ``` ```typescript export interface TransactionsResponse { transactions: Transaction[]; } ``` ```typescript export type Transaction = | TransactionWithdrawal | TransactionPayment | TransactionRefund | TransactionRefresh | TransactionDeposit | TransactionPeerPullCredit | TransactionPeerPullDebit | TransactionPeerPushCredit | TransactionPeerPushDebit | TransactionInternalWithdrawal | TransactionRecoup | TransactionDenomLoss; ``` ```typescript /** * A withdrawal transaction (either bank-integrated or manual). */ export interface TransactionWithdrawal extends TransactionCommon { type: TransactionType.Withdrawal; /** * Exchange of the withdrawal. */ exchangeBaseUrl: string | undefined; /** * 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: TalerPreciseTimestamp; /** * Scope of this tx */ scopes: ScopeInfo[]; /** * Transaction state, as per DD37. */ txState: TransactionState; /** * Possible transitions based on the current state. */ txActions: TransactionAction[]; /** * 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; abortReason?: TalerErrorDetail; failReason?: TalerErrorDetail; /** * If the transaction minor state is in KycRequired this field is going to * have the location where the user need to go to complete KYC information. */ kycUrl?: string; /** * KYC payto hash. Useful for testing, not so useful for UIs. */ kycPaytoHash?: string; /** * KYC access token. Useful for testing, not so useful for UIs. */ kycAccessToken?: string; kycAuthTransferInfo?: KycAuthTransferInfo; } ``` ```typescript export type TransactionIdStr = `txn:${string}:${string}` & { [__txId]: true; }; ``` ```typescript export declare enum TransactionType { Withdrawal = "withdrawal", InternalWithdrawal = "internal-withdrawal", Payment = "payment", Refund = "refund", Refresh = "refresh", Deposit = "deposit", PeerPushDebit = "peer-push-debit", PeerPushCredit = "peer-push-credit", PeerPullDebit = "peer-pull-debit", PeerPullCredit = "peer-pull-credit", Recoup = "recoup", DenomLoss = "denom-loss", } ``` ```typescript /** * Precise timestamp, typically used in the wallet-core * API but not in other Taler APIs so far. */ export interface TalerPreciseTimestamp { /** * Seconds (as integer) since epoch. */ readonly t_s: number | "never"; /** * Optional microsecond offset (non-negative integer). */ readonly off_us?: number; readonly _flavor?: typeof flavor_TalerPreciseTimestamp; } ``` ```typescript export interface TalerProtocolTimestamp { /** * Seconds (as integer) since epoch. */ readonly t_s: number | "never"; readonly _flavor?: typeof flavor_TalerProtocolTimestamp; } ``` ```typescript export interface TransactionState { major: TransactionMajorState; minor?: TransactionMinorState; } ``` ```typescript export declare enum TransactionMajorState { None = "none", Pending = "pending", Done = "done", Aborting = "aborting", Aborted = "aborted", Dialog = "dialog", Finalizing = "finalizing", Suspended = "suspended", SuspendedFinalizing = "suspended-finalizing", SuspendedAborting = "suspended-aborting", Failed = "failed", Expired = "expired", Deleted = "deleted", } ``` ```typescript export declare enum TransactionMinorState { Unknown = "unknown", Deposit = "deposit", KycRequired = "kyc", MergeKycRequired = "merge-kyc", BalanceKycRequired = "balance-kyc", BalanceKycInit = "balance-kyc-init", KycAuthRequired = "kyc-auth", Track = "track", SubmitPayment = "submit-payment", RebindSession = "rebind-session", Refresh = "refresh", Pickup = "pickup", AutoRefund = "auto-refund", User = "user", Bank = "bank", Exchange = "exchange", ClaimProposal = "claim-proposal", CheckRefund = "check-refund", CreatePurse = "create-purse", DeletePurse = "delete-purse", RefreshExpired = "refresh-expired", Ready = "ready", Merge = "merge", Repurchase = "repurchase", BankRegisterReserve = "bank-register-reserve", BankConfirmTransfer = "bank-confirm-transfer", WithdrawCoins = "withdraw-coins", ExchangeWaitReserve = "exchange-wait-reserve", AbortingBank = "aborting-bank", Aborting = "aborting", Refused = "refused", Withdraw = "withdraw", MerchantOrderProposed = "merchant-order-proposed", Proposed = "proposed", RefundAvailable = "refund-available", AcceptRefund = "accept-refund", PaidByOther = "paid-by-other", CompletedByOtherWallet = "completed-by-other-wallet", } ``` ```typescript export declare enum TransactionAction { Delete = "delete", Suspend = "suspend", Resume = "resume", Abort = "abort", Fail = "fail", Retry = "retry", } ``` ```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"; readonly _flavor?: typeof flavor_AbsoluteTime; [opaque_AbsoluteTime]: true; } ``` ```typescript export interface Duration { /** * Duration in milliseconds. */ readonly d_ms: number | "forever"; } ``` ```typescript export interface TalerProtocolDuration { readonly d_us: number | "forever"; } ``` ```typescript export interface KycAuthTransferInfo { /** * Payto URI of the account that must make the transfer. * * The KYC auth transfer will *not* work if it originates * from a different account. */ debitPaytoUri: string; /** * Account public key that must be included in the subject. */ accountPub: string; /** * Possible target payto URIs. */ creditPaytoUris: string[]; } ``` ```typescript export type WithdrawalDetails = | WithdrawalDetailsForManualTransfer | WithdrawalDetailsForTalerBankIntegrationApi; ``` ```typescript interface WithdrawalDetailsForManualTransfer { type: WithdrawalType.ManualTransfer; /** * Payto URIs that the exchange supports. * * Already contains the amount and message. * * @deprecated in favor of exchangeCreditAccounts */ exchangePaytoUris: string[]; exchangeCreditAccountDetails?: WithdrawalExchangeAccountDetails[]; reservePub: string; /** * Is the reserve ready for withdrawal? */ reserveIsReady: boolean; /** * How long does the exchange wait to transfer back funds from a * reserve? */ reserveClosingDelay: TalerProtocolDuration; } ``` ```typescript export interface WithdrawalExchangeAccountDetails { /** * Payto URI to credit the exchange. * * Depending on whether the (manual!) withdrawal is accepted or just * being checked, this already includes the subject with the * reserve public key. */ paytoUri: string; /** * Status that indicates whether the account can be used * by the user to send funds for a withdrawal. * * ok: account should be shown to the user * error: account should not be shown to the user, UIs might render the error (in conversionError), * especially in dev mode. */ status: "ok" | "error"; /** * Transfer amount. Might be in a different currency than the requested * amount for withdrawal. * * Absent if this is a conversion account and the conversion failed. */ transferAmount?: AmountString; /** * Currency specification for the external currency. * * Only included if this account requires a currency conversion. */ currencySpecification?: CurrencySpecification; /** * Further restrictions for sending money to the * exchange. */ creditRestrictions?: AccountRestriction[]; /** * Label given to the account or the account's bank by the exchange. */ bankLabel?: string; priority?: number; /** * Error that happened when attempting to request the conversion rate. */ conversionError?: TalerErrorDetail; } ``` ```typescript /** * DD51 https://docs.taler.net/design-documents/051-fractional-digits.html */ export interface CurrencySpecification { name: string; num_fractional_input_digits: Integer; num_fractional_normal_digits: Integer; num_fractional_trailing_zero_digits: Integer; alt_unit_names: { [log10: string]: string; }; } ``` ```typescript export type AccountRestriction = | RegexAccountRestriction | DenyAllAccountRestriction; ``` ```typescript export interface RegexAccountRestriction { type: "regex"; payto_regex: string; human_hint: string; human_hint_i18n?: InternationalizedString; } ``` ```typescript export interface InternationalizedString { [lang_tag: string]: string; } ``` ```typescript export interface DenyAllAccountRestriction { type: "deny"; } ``` ```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; /** * Is the bank transfer for the withdrawal externally confirmed? */ externalConfirmation?: boolean; exchangeCreditAccountDetails?: WithdrawalExchangeAccountDetails[]; } ``` ```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; /** * 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; /** * 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; email?: string; website?: string; logo?: ImageDataUrl; address?: Location; jurisdiction?: Location; } ``` ```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 RefundInfoShort { transactionId: string; timestamp: TalerProtocolTimestamp; amountEffective: AmountString; amountRaw: AmountString; } ``` ```typescript export interface TransactionRefund extends TransactionCommon { type: TransactionType.Refund; amountRaw: AmountString; amountEffective: AmountString; refundedTransactionId: string; paymentInfo: RefundPaymentInfo | undefined; } ``` ```typescript /** * Summary information about the payment that we got a refund for. */ export interface RefundPaymentInfo { summary: string; summary_i18n?: InternationalizedString; /** * More information about the merchant */ merchant: MerchantInfo; } ``` ```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", AbortPeerPushDebit = "abort-peer-push-debit", AbortPeerPullDebit = "abort-peer-pull-debit", 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; } ``` ```typescript export interface DepositTransactionTrackingState { 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. * * Only available in the right state. */ talerUri: string | undefined; } ``` ```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. * * Only present if the transaction is in a state where the other party can * accept the payment. */ talerUri?: string; } ``` ```typescript /** * Internal withdrawal operation, only reported on request. * * Some transactions (peer-*-credit) internally do a withdrawal, * but only the peer-*-credit transaction is reported. * * The internal withdrawal transaction allows to access the details of * the underlying withdrawal for testing/debugging. * * It is usually not reported, so that amounts of transactions properly * add up, since the amountEffecive of the withdrawal is already reported * in the peer-*-credit transaction. */ export interface TransactionInternalWithdrawal extends TransactionCommon { type: TransactionType.InternalWithdrawal; /** * 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 /** * The exchange revoked a key and the wallet recoups funds. */ export interface TransactionRecoup extends TransactionCommon { type: TransactionType.Recoup; } ``` ```typescript /** * A transaction to indicate financial loss due to denominations * that became unusable for deposits. */ export interface TransactionDenomLoss extends TransactionCommon { type: TransactionType.DenomLoss; lossEventType: DenomLossEventType; exchangeBaseUrl: string; } ``` ```typescript export declare enum DenomLossEventType { DenomExpired = "denom-expired", DenomVanished = "denom-vanished", DenomUnoffered = "denom-unoffered", } ``` ```typescript export interface AbortTransactionRequest { transactionId: TransactionIdStr; } ``` ```typescript export interface WithdrawUriInfoResponse { operationId: string; status: WithdrawalOperationStatus; confirmTransferUrl?: string; currency: string; amount: AmountString | undefined; editableAmount: boolean; maxAmount: AmountString | undefined; wireFee: AmountString | undefined; defaultExchangeBaseUrl?: string; editableExchange: boolean; possibleExchanges: ExchangeListItem[]; } ``` ```typescript export type WithdrawalOperationStatus = | "pending" | "selected" | "aborted" | "confirmed"; ``` ```typescript /** * Info about an exchange entry in the wallet. */ export interface ExchangeListItem { exchangeBaseUrl: string; masterPub: string | undefined; currency: string; paytoUris: string[]; tosStatus: ExchangeTosStatus; exchangeEntryStatus: ExchangeEntryStatus; exchangeUpdateStatus: ExchangeUpdateStatus; ageRestrictionOptions: number[]; walletKycStatus?: ExchangeWalletKycStatus; walletKycReservePub?: string; walletKycAccessToken?: string; walletKycUrl?: string; /** * P2P payments are disabled with this exchange * (e.g. because no global fees are configured). */ peerPaymentsDisabled: boolean; /** * Set to true if this exchange doesn't charge any fees. */ noFees: boolean; scopeInfo: ScopeInfo; lastUpdateTimestamp: TalerPreciseTimestamp | undefined; /** * Information about the last error that occurred when trying * to update the exchange info. */ lastUpdateErrorInfo?: OperationErrorInfo; unavailableReason?: TalerErrorDetail; } ``` ```typescript export declare enum ExchangeTosStatus { Pending = "pending", Proposed = "proposed", Accepted = "accepted", MissingTos = "missing-tos", } ``` ```typescript export declare enum ExchangeEntryStatus { Preset = "preset", Ephemeral = "ephemeral", Used = "used", } ``` ```typescript export declare enum ExchangeUpdateStatus { Initial = "initial", InitialUpdate = "initial-update", Suspended = "suspended", UnavailableUpdate = "unavailable-update", Ready = "ready", ReadyUpdate = "ready-update", OutdatedUpdate = "outdated-update", } ``` ```typescript export declare enum ExchangeWalletKycStatus { Done = "done", /** * Wallet needs to request KYC status. */ LegiInit = "legi-init", /** * User requires KYC or AML. */ Legi = "legi", } ``` ```typescript export interface OperationErrorInfo { error: TalerErrorDetail; } ``` ```typescript export interface ForcedDenomSel { denoms: { value: AmountString; count: number; }[]; } ``` ```typescript export interface AcceptWithdrawalResponse { reservePub: string; confirmTransferUrl?: string; transactionId: TransactionIdStr; } ``` ```typescript /** * Result of a prepare pay operation. */ export type PreparePayResult = | PreparePayResultInsufficientBalance | PreparePayResultAlreadyConfirmed | PreparePayResultPaymentPossible; ``` ```typescript export interface PreparePayResultInsufficientBalance { status: PreparePayResultType.InsufficientBalance; transactionId: TransactionIdStr; /** * Scopes involved in this transaction. * * For the insufficient balance response, contains scopes * of *possible* payment providers. */ scopes: ScopeInfo[]; contractTerms: MerchantContractTerms; amountRaw: AmountString; talerUri: string; balanceDetails: PaymentInsufficientBalanceDetails; } ``` ```typescript /** * Contract terms from a merchant. * FIXME: Add type field! */ export interface MerchantContractTerms { h_wire: string; auto_refund?: TalerProtocolDuration; wire_method: string; summary: string; summary_i18n?: InternationalizedString; order_id: string; amount: string; nonce: string; pay_deadline: TalerProtocolTimestamp; merchant: MerchantInfo; merchant_pub: string; delivery_date?: TalerProtocolTimestamp; delivery_location?: Location; exchanges: Exchange[]; products?: Product[]; refund_deadline: TalerProtocolTimestamp; wire_transfer_deadline: TalerProtocolTimestamp; timestamp: TalerProtocolTimestamp; merchant_base_url: string; fulfillment_url?: string; public_reorder_url?: string; fulfillment_message?: string; fulfillment_message_i18n?: InternationalizedString; max_fee: string; extra?: any; minimum_age?: Integer; } ``` ```typescript export interface Product { product_id?: string; description: string; description_i18n?: { [lang_tag: string]: string; }; quantity?: Integer; unit?: string; price?: AmountString; image?: ImageDataUrl; taxes?: Tax[]; delivery_date?: Timestamp; } ``` ```typescript export interface Tax { name: string; tax: AmountString; } ``` ```typescript /** * Detailed reason for why the wallet's balance is insufficient. */ export interface PaymentInsufficientBalanceDetails { /** * 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). */ balanceReceiverAcceptable: AmountString; /** * Balance of type "merchant-depositable" (see balance.ts for definition). */ balanceReceiverDepositable: AmountString; balanceExchangeDepositable: AmountString; /** * Maximum effective amount that the wallet can spend, * when all fees are paid by the wallet. */ maxEffectiveSpendAmount: AmountString; perExchange: { [url: string]: { balanceAvailable: AmountString; balanceMaterial: AmountString; balanceExchangeDepositable: AmountString; balanceAgeAcceptable: AmountString; balanceReceiverAcceptable: AmountString; balanceReceiverDepositable: AmountString; maxEffectiveSpendAmount: AmountString; /** * Exchange doesn't have global fees configured for the relevant year, * p2p payments aren't possible. */ missingGlobalFees: boolean; }; }; } ``` ```typescript export interface PreparePayResultAlreadyConfirmed { status: PreparePayResultType.AlreadyConfirmed; transactionId: TransactionIdStr; contractTerms: MerchantContractTerms; paid: boolean; amountRaw: AmountString; amountEffective: AmountString | undefined; /** * Scopes involved in this transaction. */ scopes: ScopeInfo[]; contractTermsHash: string; talerUri: string; } ``` ```typescript /** * Payment is possible. */ export interface PreparePayResultPaymentPossible { status: PreparePayResultType.PaymentPossible; transactionId: TransactionIdStr; contractTerms: MerchantContractTerms; /** * Scopes involved in this transaction. */ scopes: ScopeInfo[]; amountRaw: AmountString; amountEffective: AmountString; /** * FIXME: Unclear why this is needed. Remove? */ contractTermsHash: string; /** * FIXME: Unclear why this is needed! Remove? */ talerUri: string; } ``` ```typescript /** * Forced coin selection for deposits/payments. */ export interface ForcedCoinSel { coins: { value: AmountString; contribution: AmountString; }[]; } ``` ```typescript export interface AddExchangeRequest { exchangeBaseUrl: string; /** * @deprecated use a separate API call to start a forced exchange update instead */ forceUpdate?: boolean; } ``` ```typescript export interface AcceptExchangeTosRequest { exchangeBaseUrl: string; } ``` ```typescript export interface CheckDepositRequest { /** * Payto URI to identify the (bank) account that the exchange will wire * the money to. */ depositPaytoUri: string; /** * Amount that should be deposited. * * Raw amount, fees will be added on top. */ amount: AmountString; /** * ID provided by the client to cancel the request. * * If the same request is made again with the same clientCancellationId, * all previous requests are cancelled. * * The cancelled request will receive an error response with * an error code that indicates the cancellation. * * The cancellation is best-effort, responses might still arrive. */ clientCancellationId?: string; } ``` ```typescript export interface CheckDepositResponse { totalDepositCost: AmountString; effectiveDepositAmount: AmountString; fees: DepositGroupFees; kycSoftLimit?: AmountString; kycHardLimit?: AmountString; /** * Base URL of exchanges that would likely require soft KYC. */ kycExchanges?: string[]; } ``` ```typescript export interface DepositGroupFees { coin: AmountString; wire: AmountString; refresh: AmountString; } ``` ```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; } ```