10. Wallet-Core API Documentation

This file is auto-generated from wallet-core.

10.1. Overview

10.1.1. Unknown Group

10.1.2. Basic Wallet Information

10.1.6. Tipping

10.1.11. Database Management

10.2. Operation Reference

10.2.1. InitWalletOp

/**
 * Initialize wallet-core.
 *
 * Must be the request before any other operations.
 */
export type InitWalletOp = {
  op: WalletApiOperation.InitWallet;
  request: InitRequest;
  response: InitResponse;
};
// InitWallet = "initWallet"

export interface InitRequest {
  skipDefaults?: boolean;
}

export interface InitResponse {
  versionInfo: WalletCoreVersion;
}

10.2.2. GetVersionOp

export type GetVersionOp = {
  op: WalletApiOperation.GetVersion;
  request: EmptyObject;
  response: WalletCoreVersion;
};
// GetVersion = "getVersion"

10.2.3. GetBalancesOp

/**
 * Get current wallet balance.
 */
export type GetBalancesOp = {
  op: WalletApiOperation.GetBalances;
  request: EmptyObject;
  response: BalancesResponse;
};
// GetBalances = "getBalances"

export interface BalancesResponse {
  balances: Balance[];
}

export interface Balance {
  scopeInfo: ScopeInfo;
  available: AmountString;
  pendingIncoming: AmountString;
  pendingOutgoing: AmountString;
  hasPendingTransactions: boolean;
  requiresUserInput: boolean;
}

export type ScopeInfo =
  | {
      type: ScopeType.Global;
      currency: string;
    }
  | {
      type: ScopeType.Exchange;
      currency: string;
      url: string;
    }
  | {
      type: ScopeType.Auditor;
      currency: string;
      url: string;
    };

10.2.4. GetBalancesDetailOp

export type GetBalancesDetailOp = {
  op: WalletApiOperation.GetBalanceDetail;
  request: GetBalanceDetailRequest;
  response: MerchantPaymentBalanceDetails;
};
// GetBalanceDetail = "getBalanceDetail"

export interface GetBalanceDetailRequest {
  currency: string;
}

export interface MerchantPaymentBalanceDetails {
  /**
   * Balance of type "available" (see balance.ts for definition).
   */
  balanceAvailable: AmountJson;
  /**
   * Balance of type "material" (see balance.ts for definition).
   */
  balanceMaterial: AmountJson;
  /**
   * Balance of type "age-acceptable" (see balance.ts for definition).
   */
  balanceAgeAcceptable: AmountJson;
  /**
   * Balance of type "merchant-acceptable" (see balance.ts for definition).
   */
  balanceMerchantAcceptable: AmountJson;
  /**
   * Balance of type "merchant-depositable" (see balance.ts for definition).
   */
  balanceMerchantDepositable: AmountJson;
}

/**
 * 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;
}

10.2.5. GetTransactionsOp

/**
 * Get transactions.
 */
export type GetTransactionsOp = {
  op: WalletApiOperation.GetTransactions;
  request: TransactionsRequest;
  response: TransactionsResponse;
};
// GetTransactions = "getTransactions"

export interface TransactionsRequest {
  /**
   * return only transactions in the given currency
   */
  currency?: string;
  /**
   * if present, results will be limited to transactions related to the given search string
   */
  search?: string;
  /**
   * If true, include all refreshes in the transactions list.
   */
  includeRefreshes?: boolean;
}

export interface TransactionsResponse {
  transactions: Transaction[];
}

10.2.6. GetTransactionByIdOp

export type GetTransactionByIdOp = {
  op: WalletApiOperation.GetTransactionById;
  request: TransactionByIdRequest;
  response: Transaction;
};
// GetTransactionById = "getTransactionById"

export interface TransactionByIdRequest {
  transactionId: string;
}

10.2.7. RetryPendingNowOp

export type RetryPendingNowOp = {
  op: WalletApiOperation.RetryPendingNow;
  request: EmptyObject;
  response: EmptyObject;
};
// RetryPendingNow = "retryPendingNow"

10.2.8. DeleteTransactionOp

/**
 * Delete a transaction locally in the wallet.
 */
export type DeleteTransactionOp = {
  op: WalletApiOperation.DeleteTransaction;
  request: DeleteTransactionRequest;
  response: EmptyObject;
};
// DeleteTransaction = "deleteTransaction"

export interface DeleteTransactionRequest {
  transactionId: string;
}

10.2.9. RetryTransactionOp

/**
 * Immediately retry a transaction.
 */
export type RetryTransactionOp = {
  op: WalletApiOperation.RetryTransaction;
  request: RetryTransactionRequest;
  response: EmptyObject;
};
// RetryTransaction = "retryTransaction"

export interface RetryTransactionRequest {
  transactionId: string;
}

10.2.10. AbortTransactionOp

/**
 * 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"

10.2.11. SuspendTransactionOp

/**
 * Suspend a transaction
 */
export type SuspendTransactionOp = {
  op: WalletApiOperation.SuspendTransaction;
  request: AbortTransactionRequest;
  response: EmptyObject;
};
// SuspendTransaction = "suspendTransaction"

10.2.12. ResumeTransactionOp

/**
 * Resume a transaction
 */
export type ResumeTransactionOp = {
  op: WalletApiOperation.ResumeTransaction;
  request: AbortTransactionRequest;
  response: EmptyObject;
};
// ResumeTransaction = "resumeTransaction"

10.2.13. GetWithdrawalDetailsForAmountOp

/**
 * Get details for withdrawing a particular amount (manual withdrawal).
 */
export type GetWithdrawalDetailsForAmountOp = {
  op: WalletApiOperation.GetWithdrawalDetailsForAmount;
  request: GetWithdrawalDetailsForAmountRequest;
  response: ManualWithdrawalDetails;
};
// GetWithdrawalDetailsForAmount = "getWithdrawalDetailsForAmount"

export interface GetWithdrawalDetailsForAmountRequest {
  exchangeBaseUrl: string;
  amount: string;
  restrictAge?: number;
}

export interface ManualWithdrawalDetails {
  /**
   * Did the user accept the current version of the exchange's
   * terms of service?
   */
  tosAccepted: boolean;
  /**
   * Amount that the user will transfer to the exchange.
   */
  amountRaw: AmountString;
  /**
   * Amount that will be added to the user's wallet balance.
   */
  amountEffective: AmountString;
  /**
   * Ways to pay the exchange.
   */
  paytoUris: string[];
  /**
   * If the exchange supports age-restricted coins it will return
   * the array of ages.
   */
  ageRestrictionOptions?: number[];
}

10.2.14. GetWithdrawalDetailsForUriOp

/**
 * Get details for withdrawing via a particular taler:// URI.
 */
export type GetWithdrawalDetailsForUriOp = {
  op: WalletApiOperation.GetWithdrawalDetailsForUri;
  request: GetWithdrawalDetailsForUriRequest;
  response: WithdrawUriInfoResponse;
};
// GetWithdrawalDetailsForUri = "getWithdrawalDetailsForUri"

export interface GetWithdrawalDetailsForUriRequest {
  talerWithdrawUri: string;
  restrictAge?: number;
}

export interface WithdrawUriInfoResponse {
  amount: AmountString;
  defaultExchangeBaseUrl?: string;
  possibleExchanges: ExchangeListItem[];
}

10.2.15. AcceptBankIntegratedWithdrawalOp

/**
 * Accept a bank-integrated withdrawal.
 */
export type AcceptBankIntegratedWithdrawalOp = {
  op: WalletApiOperation.AcceptBankIntegratedWithdrawal;
  request: AcceptBankIntegratedWithdrawalRequest;
  response: AcceptWithdrawalResponse;
};
// AcceptBankIntegratedWithdrawal = "acceptBankIntegratedWithdrawal"

export interface AcceptBankIntegratedWithdrawalRequest {
  talerWithdrawUri: string;
  exchangeBaseUrl: string;
  forcedDenomSel?: ForcedDenomSel;
  restrictAge?: number;
}

export interface AcceptWithdrawalResponse {
  reservePub: string;
  confirmTransferUrl?: string;
  transactionId: string;
}

10.2.16. AcceptManualWithdrawalOp

/**
 * Create a manual withdrawal.
 */
export type AcceptManualWithdrawalOp = {
  op: WalletApiOperation.AcceptManualWithdrawal;
  request: AcceptManualWithdrawalRequest;
  response: AcceptManualWithdrawalResult;
};
// AcceptManualWithdrawal = "acceptManualWithdrawal"

export interface AcceptManualWithdrawalRequest {
  exchangeBaseUrl: string;
  amount: string;
  restrictAge?: number;
}

export interface AcceptManualWithdrawalResult {
  /**
   * Payto URIs that can be used to fund the withdrawal.
   */
  exchangePaytoUris: string[];
  /**
   * Public key of the newly created reserve.
   */
  reservePub: string;
  transactionId: string;
}

10.2.17. PreparePayForUriOp

/**
 * Prepare to make a payment based on a taler://pay/ URI.
 */
export type PreparePayForUriOp = {
  op: WalletApiOperation.PreparePayForUri;
  request: PreparePayRequest;
  response: PreparePayResult;
};
// PreparePayForUri = "preparePayForUri"

export interface PreparePayRequest {
  talerPayUri: string;
}

10.2.18. PreparePayForTemplateOp

/**
 * Prepare to make a payment based on a taler://pay-template/ URI.
 */
export type PreparePayForTemplateOp = {
  op: WalletApiOperation.PreparePayForTemplate;
  request: PreparePayTemplateRequest;
  response: PreparePayResult;
};
// PreparePayForTemplate = "preparePayForTemplate"

export interface PreparePayTemplateRequest {
  talerPayTemplateUri: string;
  templateParams: Record<string, string>;
}

10.2.19. GetContractTermsDetailsOp

export type GetContractTermsDetailsOp = {
  op: WalletApiOperation.GetContractTermsDetails;
  request: GetContractTermsDetailsRequest;
  response: WalletContractData;
};
// GetContractTermsDetails = "getContractTermsDetails"

export interface GetContractTermsDetailsRequest {
  proposalId: string;
}

/**
 * Data extracted from the contract terms that is relevant for payment
 * processing in the wallet.
 */
export interface WalletContractData {
  products?: Product[];
  summaryI18n:
    | {
        [lang_tag: string]: string;
      }
    | undefined;
  /**
   * Fulfillment URL, or the empty string if the order has no fulfillment URL.
   *
   * Stored as a non-nullable string as we use this field for IndexedDB indexing.
   */
  fulfillmentUrl: string;
  contractTermsHash: string;
  fulfillmentMessage?: string;
  fulfillmentMessageI18n?: InternationalizedString;
  merchantSig: string;
  merchantPub: string;
  merchant: MerchantInfo;
  amount: AmountString;
  orderId: string;
  merchantBaseUrl: string;
  summary: string;
  autoRefund: TalerProtocolDuration | undefined;
  maxWireFee: AmountString;
  wireFeeAmortization: number;
  payDeadline: TalerProtocolTimestamp;
  refundDeadline: TalerProtocolTimestamp;
  allowedAuditors: AllowedAuditorInfo[];
  allowedExchanges: AllowedExchangeInfo[];
  timestamp: TalerProtocolTimestamp;
  wireMethod: string;
  wireInfoHash: string;
  maxDepositFee: AmountString;
  minimumAge?: number;
  deliveryDate: TalerProtocolTimestamp | undefined;
  deliveryLocation: Location | undefined;
}

export interface AllowedAuditorInfo {
  auditorBaseUrl: string;
  auditorPub: string;
}

export interface AllowedExchangeInfo {
  exchangeBaseUrl: string;
  exchangePub: string;
}

10.2.20. ConfirmPayOp

/**
 * Confirm a payment that was previously prepared with
 * {@link PreparePayForUriOp}
 */
export type ConfirmPayOp = {
  op: WalletApiOperation.ConfirmPay;
  request: ConfirmPayRequest;
  response: ConfirmPayResult;
};
// ConfirmPay = "confirmPay"

export interface ConfirmPayRequest {
  proposalId: string;
  sessionId?: string;
  forcedCoinSel?: ForcedCoinSel;
}

export type ConfirmPayResult = ConfirmPayResultDone | ConfirmPayResultPending;

/**
 * Result for confirmPay
 */
export interface ConfirmPayResultDone {
  type: ConfirmPayResultType.Done;
  contractTerms: MerchantContractTerms;
  transactionId: string;
}

export interface ConfirmPayResultPending {
  type: ConfirmPayResultType.Pending;
  transactionId: string;
  lastError: TalerErrorDetail | undefined;
}

10.2.21. ApplyRefundOp

/**
 * Check for a refund based on a taler://refund URI.
 */
export type ApplyRefundOp = {
  op: WalletApiOperation.ApplyRefund;
  request: ApplyRefundRequest;
  response: ApplyRefundResponse;
};
// ApplyRefund = "applyRefund"

export interface ApplyRefundRequest {
  talerRefundUri: string;
}

10.2.22. ApplyRefundFromPurchaseIdOp

export type ApplyRefundFromPurchaseIdOp = {
  op: WalletApiOperation.ApplyRefundFromPurchaseId;
  request: ApplyRefundFromPurchaseIdRequest;
  response: ApplyRefundResponse;
};
// ApplyRefundFromPurchaseId = "applyRefundFromPurchaseId"

export interface ApplyRefundFromPurchaseIdRequest {
  purchaseId: string;
}

10.2.23. PrepareRefundOp

export type PrepareRefundOp = {
  op: WalletApiOperation.PrepareRefund;
  request: PrepareRefundRequest;
  response: PrepareRefundResult;
};
// PrepareRefund = "prepareRefund"

export interface PrepareRefundRequest {
  talerRefundUri: string;
}

export interface PrepareRefundResult {
  proposalId: string;
  effectivePaid: AmountString;
  gone: AmountString;
  granted: AmountString;
  pending: boolean;
  awaiting: AmountString;
  info: OrderShortInfo;
}

10.2.24. PrepareTipOp

/**
 * Query and store information about a tip.
 */
export type PrepareTipOp = {
  op: WalletApiOperation.PrepareTip;
  request: PrepareTipRequest;
  response: PrepareTipResult;
};
// PrepareTip = "prepareTip"

export interface PrepareTipRequest {
  talerTipUri: string;
}

export interface PrepareTipResult {
  /**
   * Unique ID for the tip assigned by the wallet.
   * Typically different from the merchant-generated tip ID.
   */
  walletTipId: string;
  /**
   * Has the tip already been accepted?
   */
  accepted: boolean;
  /**
   * Amount that the merchant gave.
   */
  tipAmountRaw: AmountString;
  /**
   * Amount that arrived at the wallet.
   * Might be lower than the raw amount due to fees.
   */
  tipAmountEffective: AmountString;
  /**
   * Base URL of the merchant backend giving then tip.
   */
  merchantBaseUrl: string;
  /**
   * Base URL of the exchange that is used to withdraw the tip.
   * Determined by the merchant, the wallet/user has no choice here.
   */
  exchangeBaseUrl: string;
  /**
   * Time when the tip will expire.  After it expired, it can't be picked
   * up anymore.
   */
  expirationTimestamp: TalerProtocolTimestamp;
}

10.2.25. AcceptTipOp

/**
 * Accept a tip.
 */
export type AcceptTipOp = {
  op: WalletApiOperation.AcceptTip;
  request: AcceptTipRequest;
  response: AcceptTipResponse;
};
// AcceptTip = "acceptTip"

export interface AcceptTipRequest {
  walletTipId: string;
}

export interface AcceptTipResponse {
  transactionId: string;
  next_url?: string;
}

10.2.26. ListExchangesOp

/**
 * List exchanges known to the wallet.
 */
export type ListExchangesOp = {
  op: WalletApiOperation.ListExchanges;
  request: EmptyObject;
  response: ExchangesListResponse;
};
// ListExchanges = "listExchanges"

export interface ExchangesListResponse {
  exchanges: ExchangeListItem[];
}

10.2.27. AddExchangeOp

/**
 * Add / force-update an exchange.
 */
export type AddExchangeOp = {
  op: WalletApiOperation.AddExchange;
  request: AddExchangeRequest;
  response: EmptyObject;
};
// AddExchange = "addExchange"

10.2.28. ListKnownBankAccountsOp

export type ListKnownBankAccountsOp = {
  op: WalletApiOperation.ListKnownBankAccounts;
  request: ListKnownBankAccountsRequest;
  response: KnownBankAccounts;
};
// ListKnownBankAccounts = "listKnownBankAccounts"

export interface ListKnownBankAccountsRequest {
  currency?: string;
}

export interface KnownBankAccounts {
  accounts: KnownBankAccountsInfo[];
}

export interface KnownBankAccountsInfo {
  uri: PaytoUri;
  kyc_completed: boolean;
  currency: string;
  alias: string;
}

export type PaytoUri =
  | PaytoUriUnknown
  | PaytoUriIBAN
  | PaytoUriTalerBank
  | PaytoUriBitcoin;

export interface PaytoUriUnknown extends PaytoUriGeneric {
  isKnown: false;
}

export interface PaytoUriGeneric {
  targetType: string;
  targetPath: string;
  params: {
    [name: string]: string;
  };
}

export interface PaytoUriIBAN extends PaytoUriGeneric {
  isKnown: true;
  targetType: "iban";
  iban: string;
  bic?: string;
}

export interface PaytoUriTalerBank extends PaytoUriGeneric {
  isKnown: true;
  targetType: "x-taler-bank";
  host: string;
  account: string;
}

export interface PaytoUriBitcoin extends PaytoUriGeneric {
  isKnown: true;
  targetType: "bitcoin";
  segwitAddrs: Array<string>;
}

10.2.29. AddKnownBankAccountsOp

export type AddKnownBankAccountsOp = {
  op: WalletApiOperation.AddKnownBankAccounts;
  request: AddKnownBankAccountsRequest;
  response: EmptyObject;
};
// AddKnownBankAccounts = "addKnownBankAccounts"

export interface AddKnownBankAccountsRequest {
  payto: string;
  alias: string;
  currency: string;
}

10.2.30. ForgetKnownBankAccountsOp

export type ForgetKnownBankAccountsOp = {
  op: WalletApiOperation.ForgetKnownBankAccounts;
  request: ForgetKnownBankAccountsRequest;
  response: EmptyObject;
};
// ForgetKnownBankAccounts = "forgetKnownBankAccounts"

export interface ForgetKnownBankAccountsRequest {
  payto: string;
}

10.2.31. SetExchangeTosAcceptedOp

/**
 * Accept a particular version of the exchange terms of service.
 */
export type SetExchangeTosAcceptedOp = {
  op: WalletApiOperation.SetExchangeTosAccepted;
  request: AcceptExchangeTosRequest;
  response: EmptyObject;
};
// SetExchangeTosAccepted = "setExchangeTosAccepted"

export interface AcceptExchangeTosRequest {
  exchangeBaseUrl: string;
  etag: string | undefined;
}

10.2.32. GetExchangeTosOp

/**
 * Get the current terms of a service of an exchange.
 */
export type GetExchangeTosOp = {
  op: WalletApiOperation.GetExchangeTos;
  request: GetExchangeTosRequest;
  response: GetExchangeTosResult;
};
// GetExchangeTos = "getExchangeTos"

export interface GetExchangeTosRequest {
  exchangeBaseUrl: string;
  acceptedFormat?: string[];
}

export interface GetExchangeTosResult {
  /**
   * Markdown version of the current ToS.
   */
  content: string;
  /**
   * Version tag of the current ToS.
   */
  currentEtag: string;
  /**
   * Version tag of the last ToS that the user has accepted,
   * if any.
   */
  acceptedEtag: string | undefined;
  /**
   * Accepted content type
   */
  contentType: string;
  tosStatus: ExchangeTosStatus;
}

10.2.33. GetExchangeDetailedInfoOp

/**
 * Get the current terms of a service of an exchange.
 */
export type GetExchangeDetailedInfoOp = {
  op: WalletApiOperation.GetExchangeDetailedInfo;
  request: AddExchangeRequest;
  response: ExchangeDetailedResponse;
};
// GetExchangeDetailedInfo = "getExchangeDetailedInfo"

export interface ExchangeDetailedResponse {
  exchange: ExchangeFullDetails;
}

export interface ExchangeFullDetails {
  exchangeBaseUrl: string;
  currency: string;
  paytoUris: string[];
  tos: ExchangeTosStatusDetails;
  auditors: ExchangeAuditor[];
  wireInfo: WireInfo;
  denomFees: DenomOperationMap<FeeDescription[]>;
  transferFees: Record<string, FeeDescription[]>;
  globalFees: FeeDescription[];
}

export interface ExchangeTosStatusDetails {
  acceptedVersion?: string;
  currentVersion?: string;
  contentType?: string;
  content?: string;
}

export interface WireInfo {
  feesForType: WireFeeMap;
  accounts: ExchangeAccount[];
}

/**
 * Information about one of the exchange's bank accounts.
 */
export interface ExchangeAccount {
  payto_uri: string;
  master_sig: string;
}

export interface FeeDescription {
  group: string;
  from: AbsoluteTime;
  until: AbsoluteTime;
  fee?: AmountString;
}

10.2.34. ListCurrenciesOp

/**
 * List currencies known to the wallet.
 */
export type ListCurrenciesOp = {
  op: WalletApiOperation.ListCurrencies;
  request: EmptyObject;
  response: WalletCurrencyInfo;
};
// ListCurrencies = "listCurrencies"

export interface WalletCurrencyInfo {
  trustedAuditors: {
    currency: string;
    auditorPub: string;
    auditorBaseUrl: string;
  }[];
  trustedExchanges: {
    currency: string;
    exchangeMasterPub: string;
    exchangeBaseUrl: string;
  }[];
}

10.2.35. CreateDepositGroupOp

/**
 * 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"

export interface CreateDepositGroupRequest {
  depositPaytoUri: string;
  amount: AmountString;
}

export interface CreateDepositGroupResponse {
  depositGroupId: string;
  transactionId: string;
}

10.2.36. TrackDepositGroupOp

/**
 * Track the status of a deposit group by querying the exchange.
 */
export type TrackDepositGroupOp = {
  op: WalletApiOperation.TrackDepositGroup;
  request: TrackDepositGroupRequest;
  response: TrackDepositGroupResponse;
};
// TrackDepositGroup = "trackDepositGroup"

export interface TrackDepositGroupRequest {
  depositGroupId: string;
}

export interface TrackDepositGroupResponse {
  responses: TrackTransaction[];
}

export type TrackTransaction =
  | ({
      type: "accepted";
    } & TrackTransactionAccepted)
  | ({
      type: "wired";
    } & TrackTransactionWired);

interface TrackTransactionAccepted {
  requirement_row?: number;
  kyc_ok: boolean;
  execution_time: TalerProtocolTimestamp;
}

export interface TrackTransactionWired {
  wtid: Base32String;
  execution_time: TalerProtocolTimestamp;
  coin_contribution: AmountString;
  exchange_sig: EddsaSignatureString;
  exchange_pub: EddsaPublicKeyString;
}

10.2.37. GetFeeForDepositOp

export type GetFeeForDepositOp = {
  op: WalletApiOperation.GetFeeForDeposit;
  request: GetFeeForDepositRequest;
  response: DepositGroupFees;
};
// GetFeeForDeposit = "getFeeForDeposit"

export interface GetFeeForDepositRequest {
  depositPaytoUri: string;
  amount: AmountString;
}

export interface DepositGroupFees {
  coin: AmountString;
  wire: AmountString;
  refresh: AmountString;
}

10.2.38. PrepareDepositOp

export type PrepareDepositOp = {
  op: WalletApiOperation.PrepareDeposit;
  request: PrepareDepositRequest;
  response: PrepareDepositResponse;
};
// PrepareDeposit = "prepareDeposit"

export interface PrepareDepositRequest {
  depositPaytoUri: string;
  amount: AmountString;
}

export interface PrepareDepositResponse {
  totalDepositCost: AmountString;
  effectiveDepositAmount: AmountString;
}

10.2.39. ExportBackupRecoveryOp

/**
 * Export the recovery information for the wallet.
 */
export type ExportBackupRecoveryOp = {
  op: WalletApiOperation.ExportBackupRecovery;
  request: EmptyObject;
  response: BackupRecovery;
};
// ExportBackupRecovery = "exportBackupRecovery"

10.2.40. ImportBackupRecoveryOp

/**
 * Import recovery information into the wallet.
 */
export type ImportBackupRecoveryOp = {
  op: WalletApiOperation.ImportBackupRecovery;
  request: RecoveryLoadRequest;
  response: EmptyObject;
};
// ImportBackupRecovery = "importBackupRecovery"

/**
 * Load recovery information into the wallet.
 */
export interface RecoveryLoadRequest {
  recovery: BackupRecovery;
  strategy?: RecoveryMergeStrategy;
}

/**
 * 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",
}

10.2.41. RunBackupCycleOp

/**
 * Manually make and upload a backup.
 */
export type RunBackupCycleOp = {
  op: WalletApiOperation.RunBackupCycle;
  request: RunBackupCycleRequest;
  response: EmptyObject;
};
// RunBackupCycle = "runBackupCycle"

export interface RunBackupCycleRequest {
  /**
   * List of providers to backup or empty for all known providers.
   */
  providers?: Array<string>;
}

10.2.42. ExportBackupOp

export type ExportBackupOp = {
  op: WalletApiOperation.ExportBackup;
  request: EmptyObject;
  response: EmptyObject;
};
// ExportBackup = "exportBackup"

10.2.43. AddBackupProviderOp

/**
 * Add a new backup provider.
 */
export type AddBackupProviderOp = {
  op: WalletApiOperation.AddBackupProvider;
  request: AddBackupProviderRequest;
  response: AddBackupProviderResponse;
};
// AddBackupProvider = "addBackupProvider"

export interface AddBackupProviderRequest {
  backupProviderBaseUrl: string;
  name: string;
  /**
   * Activate the provider.  Should only be done after
   * the user has reviewed the provider.
   */
  activate?: boolean;
}

export type AddBackupProviderResponse =
  | AddBackupProviderOk
  | AddBackupProviderPaymentRequired;

interface AddBackupProviderOk {
  status: "ok";
}

interface AddBackupProviderPaymentRequired {
  status: "payment-required";
  talerUri?: string;
}

10.2.44. RemoveBackupProviderOp

export type RemoveBackupProviderOp = {
  op: WalletApiOperation.RemoveBackupProvider;
  request: RemoveBackupProviderRequest;
  response: EmptyObject;
};
// RemoveBackupProvider = "removeBackupProvider"

export interface RemoveBackupProviderRequest {
  provider: string;
}

10.2.45. GetBackupInfoOp

/**
 * Get some useful stats about the backup state.
 */
export type GetBackupInfoOp = {
  op: WalletApiOperation.GetBackupInfo;
  request: EmptyObject;
  response: BackupInfo;
};
// GetBackupInfo = "getBackupInfo"

export interface BackupInfo {
  walletRootPub: string;
  deviceId: string;
  providers: ProviderInfo[];
}

/**
 * Information about one provider.
 *
 * We don't store the account key here,
 * as that's derived from the wallet root key.
 */
export interface ProviderInfo {
  active: boolean;
  syncProviderBaseUrl: string;
  name: string;
  terms?: BackupProviderTerms;
  /**
   * Last communication issue with the provider.
   */
  lastError?: TalerErrorDetail;
  lastSuccessfulBackupTimestamp?: TalerProtocolTimestamp;
  lastAttemptedBackupTimestamp?: TalerProtocolTimestamp;
  paymentProposalIds: string[];
  backupProblem?: BackupProblem;
  paymentStatus: ProviderPaymentStatus;
}

export interface BackupProviderTerms {
  supportedProtocolVersion: string;
  annualFee: AmountString;
  storageLimitInMegabytes: number;
}

export type BackupProblem =
  | BackupUnreadableProblem
  | BackupConflictingDeviceProblem;

export interface BackupUnreadableProblem {
  type: "backup-unreadable";
}

export interface BackupConflictingDeviceProblem {
  type: "backup-conflicting-device";
  otherDeviceId: string;
  myDeviceId: string;
  backupTimestamp: AbsoluteTime;
}

export type ProviderPaymentStatus =
  | ProviderPaymentTermsChanged
  | ProviderPaymentPaid
  | ProviderPaymentInsufficientBalance
  | ProviderPaymentUnpaid
  | ProviderPaymentPending;

export interface ProviderPaymentTermsChanged {
  type: ProviderPaymentType.TermsChanged;
  paidUntil: AbsoluteTime;
  oldTerms: BackupProviderTerms;
  newTerms: BackupProviderTerms;
}

export interface ProviderPaymentPaid {
  type: ProviderPaymentType.Paid;
  paidUntil: AbsoluteTime;
}

export interface ProviderPaymentInsufficientBalance {
  type: ProviderPaymentType.InsufficientBalance;
  amount: AmountString;
}

export interface ProviderPaymentUnpaid {
  type: ProviderPaymentType.Unpaid;
}

export interface ProviderPaymentPending {
  type: ProviderPaymentType.Pending;
  talerUri?: string;
}

10.2.46. SetWalletDeviceIdOp

/**
 * 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"

export interface SetWalletDeviceIdRequest {
  /**
   * New wallet device ID to set.
   */
  walletDeviceId: string;
}

10.2.47. ExportBackupPlainOp

/**
 * Export a backup JSON, mostly useful for testing.
 */
export type ExportBackupPlainOp = {
  op: WalletApiOperation.ExportBackupPlain;
  request: EmptyObject;
  response: WalletBackupContentV1;
};
// ExportBackupPlain = "exportBackupPlain"

10.2.48. CheckPeerPushDebitOp

/**
 * 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"

export interface CheckPeerPushDebitRequest {
  /**
   * Preferred exchange to use for the p2p payment.
   */
  exchangeBaseUrl?: string;
  /**
   * Instructed amount.
   *
   * FIXME: Allow specifying the instructed amount type.
   */
  amount: AmountString;
}

export interface CheckPeerPushDebitResponse {
  amountRaw: AmountString;
  amountEffective: AmountString;
}

10.2.49. InitiatePeerPushDebitOp

/**
 * Initiate an outgoing peer push payment.
 */
export type InitiatePeerPushDebitOp = {
  op: WalletApiOperation.InitiatePeerPushDebit;
  request: InitiatePeerPushPaymentRequest;
  response: InitiatePeerPushPaymentResponse;
};
// InitiatePeerPushDebit = "initiatePeerPushDebit"

export interface InitiatePeerPushPaymentRequest {
  exchangeBaseUrl?: string;
  partialContractTerms: PeerContractTerms;
}

export interface InitiatePeerPushPaymentResponse {
  exchangeBaseUrl: string;
  pursePub: string;
  mergePriv: string;
  contractPriv: string;
  talerUri: string;
  transactionId: string;
}

10.2.50. PreparePeerPushCreditOp

/**
 * Check an incoming peer push payment.
 */
export type PreparePeerPushCreditOp = {
  op: WalletApiOperation.PreparePeerPushCredit;
  request: PreparePeerPushCredit;
  response: PreparePeerPushCreditResponse;
};
// PreparePeerPushCredit = "preparePeerPushCredit"

export interface PreparePeerPushCreditResponse {
  contractTerms: PeerContractTerms;
  /**
   * @deprecated
   */
  amount: AmountString;
  amountRaw: AmountString;
  amountEffective: AmountString;
  peerPushPaymentIncomingId: string;
}

10.2.51. ConfirmPeerPushCreditOp

/**
 * Accept an incoming peer push payment.
 */
export type ConfirmPeerPushCreditOp = {
  op: WalletApiOperation.ConfirmPeerPushCredit;
  request: ConfirmPeerPushCreditRequest;
  response: EmptyObject;
};
// ConfirmPeerPushCredit = "confirmPeerPushCredit"

export interface ConfirmPeerPushCreditRequest {
  /**
   * Transparent identifier of the incoming peer push payment.
   */
  peerPushPaymentIncomingId: string;
}

10.2.52. CheckPeerPullCreditOp

/**
 * Check fees for an outgoing peer pull payment.
 */
export type CheckPeerPullCreditOp = {
  op: WalletApiOperation.CheckPeerPullCredit;
  request: CheckPeerPullCreditRequest;
  response: CheckPeerPullCreditResponse;
};
// CheckPeerPullCredit = "checkPeerPullCredit"

export interface CheckPeerPullCreditRequest {
  exchangeBaseUrl?: string;
  amount: AmountString;
}

export interface CheckPeerPullCreditResponse {
  exchangeBaseUrl: string;
  amountRaw: AmountString;
  amountEffective: AmountString;
}

10.2.53. InitiatePeerPullCreditOp

/**
 * Initiate an outgoing peer pull payment.
 */
export type InitiatePeerPullCreditOp = {
  op: WalletApiOperation.InitiatePeerPullCredit;
  request: InitiatePeerPullCreditRequest;
  response: InitiatePeerPullCreditResponse;
};
// InitiatePeerPullCredit = "initiatePeerPullCredit"

export interface InitiatePeerPullCreditRequest {
  exchangeBaseUrl?: string;
  partialContractTerms: PeerContractTerms;
}

export interface InitiatePeerPullCreditResponse {
  /**
   * Taler URI for the other party to make the payment
   * that was requested.
   */
  talerUri: string;
  transactionId: string;
}

10.2.54. PreparePeerPullDebitOp

/**
 * Prepare for an incoming peer pull payment.
 */
export type PreparePeerPullDebitOp = {
  op: WalletApiOperation.PreparePeerPullDebit;
  request: PreparePeerPullDebitRequest;
  response: PreparePeerPullDebitResponse;
};
// PreparePeerPullDebit = "preparePeerPullDebit"

export interface PreparePeerPullDebitRequest {
  talerUri: string;
}

export interface PreparePeerPullDebitResponse {
  contractTerms: PeerContractTerms;
  /**
   * @deprecated Redundant field with bad name, will be removed soon.
   */
  amount: AmountString;
  amountRaw: AmountString;
  amountEffective: AmountString;
  peerPullPaymentIncomingId: string;
}

10.2.55. ConfirmPeerPullDebitOp

/**
 * Accept an incoming peer pull payment (i.e. pay the other party).
 */
export type ConfirmPeerPullDebitOp = {
  op: WalletApiOperation.ConfirmPeerPullDebit;
  request: ConfirmPeerPullDebitRequest;
  response: EmptyObject;
};
// ConfirmPeerPullDebit = "confirmPeerPullDebit"

export interface ConfirmPeerPullDebitRequest {
  /**
   * Transparent identifier of the incoming peer pull payment.
   */
  peerPullPaymentIncomingId: string;
}

10.2.56. ExportDbOp

/**
 * Export the wallet database's contents to JSON.
 */
export type ExportDbOp = {
  op: WalletApiOperation.ExportDb;
  request: EmptyObject;
  response: any;
};
// ExportDb = "exportDb"

10.2.57. ImportDbOp

export type ImportDbOp = {
  op: WalletApiOperation.ImportDb;
  request: any;
  response: any;
};
// ImportDb = "importDb"

10.2.58. ClearDbOp

/**
 * Dangerously clear the whole wallet database.
 */
export type ClearDbOp = {
  op: WalletApiOperation.ClearDb;
  request: EmptyObject;
  response: EmptyObject;
};
// ClearDb = "clearDb"

10.2.59. RecycleOp

/**
 * Export a backup, clear the database and re-import it.
 */
export type RecycleOp = {
  op: WalletApiOperation.Recycle;
  request: EmptyObject;
  response: EmptyObject;
};
// Recycle = "recycle"

10.2.60. ApplyDevExperimentOp

/**
 * 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"

export interface ApplyDevExperimentRequest {
  devExperimentUri: string;
}

10.2.61. SetDevModeOp

export type SetDevModeOp = {
  op: WalletApiOperation.SetDevMode;
  request: SetDevModeRequest;
  response: EmptyObject;
};
// SetDevMode = "setDevMode"

export interface SetDevModeRequest {
  devModeEnabled: boolean;
}

10.2.62. RunIntegrationTestOp

/**
 * 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"

export interface IntegrationTestArgs {
  exchangeBaseUrl: string;
  bankBaseUrl: string;
  bankAccessApiBaseUrl?: string;
  merchantBaseUrl: string;
  merchantAuthToken?: string;
  amountToWithdraw: string;
  amountToSpend: string;
}

10.2.63. TestCryptoOp

/**
 * Test crypto worker.
 */
export type TestCryptoOp = {
  op: WalletApiOperation.TestCrypto;
  request: EmptyObject;
  response: any;
};
// TestCrypto = "testCrypto"

10.2.64. WithdrawTestBalanceOp

/**
 * Make withdrawal on a test deployment of the exchange
 * and merchant.
 */
export type WithdrawTestBalanceOp = {
  op: WalletApiOperation.WithdrawTestBalance;
  request: WithdrawTestBalanceRequest;
  response: EmptyObject;
};
// WithdrawTestBalance = "withdrawTestBalance"

export interface WithdrawTestBalanceRequest {
  amount: string;
  bankBaseUrl: string;
  /**
   * Bank access API base URL.  Defaults to the bankBaseUrl.
   */
  bankAccessApiBaseUrl?: string;
  exchangeBaseUrl: string;
  forcedDenomSel?: ForcedDenomSel;
}

10.2.65. WithdrawTestkudosOp

/**
 * Make a withdrawal of testkudos on test.taler.net.
 */
export type WithdrawTestkudosOp = {
  op: WalletApiOperation.WithdrawTestkudos;
  request: EmptyObject;
  response: EmptyObject;
};
// WithdrawTestkudos = "withdrawTestkudos"

10.2.66. TestPayOp

/**
 * 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"

export interface TestPayArgs {
  merchantBaseUrl: string;
  merchantAuthToken?: string;
  amount: string;
  summary: string;
  forcedCoinSel?: ForcedCoinSel;
}

export interface TestPayResult {
  payCoinSelection: PayCoinSelection;
}

/**
 * Result of selecting coins, contains the exchange, and selected
 * coins with their denomination.
 */
export interface PayCoinSelection {
  /**
   * Amount requested by the merchant.
   */
  paymentAmount: AmountString;
  /**
   * Public keys of the coins that were selected.
   */
  coinPubs: string[];
  /**
   * Amount that each coin contributes.
   */
  coinContributions: AmountString[];
  /**
   * How much of the wire fees is the customer paying?
   */
  customerWireFees: AmountString;
  /**
   * How much of the deposit fees is the customer paying?
   */
  customerDepositFees: AmountString;
}

10.2.67. WithdrawFakebankOp

/**
 * Make a withdrawal from a fakebank, i.e.
 * a bank where test users can be registered freely
 * and testing APIs are available.
 */
export type WithdrawFakebankOp = {
  op: WalletApiOperation.WithdrawFakebank;
  request: WithdrawFakebankRequest;
  response: EmptyObject;
};
// WithdrawFakebank = "withdrawFakebank"

export interface WithdrawFakebankRequest {
  amount: AmountString;
  exchange: string;
  bank: string;
}

10.2.68. GetPendingTasksOp

/**
 * Get wallet-internal pending tasks.
 */
export type GetPendingTasksOp = {
  op: WalletApiOperation.GetPendingOperations;
  request: EmptyObject;
  response: PendingTasksResponse;
};
// GetPendingOperations = "getPendingOperations"

/**
 * Response returned from the pending operations API.
 */
export interface PendingOperationsResponse {
  /**
   * List of pending operations.
   */
  pendingOperations: PendingTaskInfo[];
}

/**
 * Information about a pending operation.
 */
export type PendingTaskInfo = PendingTaskInfoCommon &
  (
    | PendingExchangeUpdateTask
    | PendingExchangeCheckRefreshTask
    | PendingPurchaseTask
    | PendingRefreshTask
    | PendingTipPickupTask
    | PendingWithdrawTask
    | PendingRecoupTask
    | PendingDepositTask
    | PendingBackupTask
    | PendingPeerPushInitiationTask
    | PendingPeerPullInitiationTask
    | PendingPeerPullDebitTask
    | PendingPeerPushCreditTask
  );

/**
 * Fields that are present in every pending operation.
 */
export interface PendingTaskInfoCommon {
  /**
   * Type of the pending operation.
   */
  type: PendingTaskType;
  /**
   * Unique identifier for the pending task.
   */
  id: string;
  /**
   * Set to true if the operation indicates that something is really in progress,
   * as opposed to some regular scheduled operation that can be tried later.
   */
  givesLifeness: boolean;
  /**
   * Operation is active and waiting for a longpoll result.
   */
  isLongpolling: boolean;
  /**
   * Operation is waiting to be executed.
   */
  isDue: boolean;
  /**
   * Timestamp when the pending operation should be executed next.
   */
  timestampDue: AbsoluteTime;
  /**
   * Retry info.  Currently used to stop the wallet after any operation
   * exceeds a number of retries.
   */
  retryInfo?: RetryInfo;
}

export enum PendingTaskType {
  ExchangeUpdate = "exchange-update",
  ExchangeCheckRefresh = "exchange-check-refresh",
  Purchase = "purchase",
  Refresh = "refresh",
  Recoup = "recoup",
  TipPickup = "tip-pickup",
  Withdraw = "withdraw",
  Deposit = "deposit",
  Backup = "backup",
  // FIXME: Rename to peer-push-debit and peer-pull-debit
  PeerPushInitiation = "peer-push-initiation",
  PeerPullInitiation = "peer-pull-initiation",
  PeerPushCredit = "peer-push-credit",
  PeerPullDebit = "peer-pull-debit",
}

export interface RetryInfo {
  firstTry: AbsoluteTime;
  nextRetry: AbsoluteTime;
  retryCounter: number;
}

export interface RetryPolicy {
  readonly backoffDelta: Duration;
  readonly backoffBase: number;
  readonly maxTimeout: Duration;
}

// Declare "static" methods in Error
interface ErrorConstructor {
  /** Create .stack property on a target object */
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
  /**
   * Optional override for formatting stack traces
   *
   * @see https://v8.dev/docs/stack-trace-api#customizing-stack-traces
   */
  prepareStackTrace?:
    | ((err: Error, stackTraces: NodeJS.CallSite[]) => any)
    | undefined;
  stackTraceLimit: number;
}

interface CallSite {
  /**
   * Value of "this"
   */
  getThis(): unknown;
  /**
   * Type of "this" as a string.
   * This is the name of the function stored in the constructor field of
   * "this", if available.  Otherwise the object's [[Class]] internal
   * property.
   */
  getTypeName(): string | null;
  /**
   * Current function
   */
  getFunction(): Function | undefined;
  /**
   * Name of the current function, typically its name property.
   * If a name property is not available an attempt will be made to try
   * to infer a name from the function's context.
   */
  getFunctionName(): string | null;
  /**
   * Name of the property [of "this" or one of its prototypes] that holds
   * the current function
   */
  getMethodName(): string | null;
  /**
   * Name of the script [if this function was defined in a script]
   */
  getFileName(): string | null;
  /**
   * Current line number [if this function was defined in a script]
   */
  getLineNumber(): number | null;
  /**
   * Current column number [if this function was defined in a script]
   */
  getColumnNumber(): number | null;
  /**
   * A call site object representing the location where eval was called
   * [if this function was created using a call to eval]
   */
  getEvalOrigin(): string | undefined;
  /**
   * Is this a toplevel invocation, that is, is "this" the global object?
   */
  isToplevel(): boolean;
  /**
   * Does this call take place in code defined by a call to eval?
   */
  isEval(): boolean;
  /**
   * Is this call in native V8 code?
   */
  isNative(): boolean;
  /**
   * Is this a constructor call?
   */
  isConstructor(): boolean;
}

/**
 * The wallet is currently updating information about an exchange.
 */
export interface PendingExchangeUpdateTask {
  type: PendingTaskType.ExchangeUpdate;
  exchangeBaseUrl: string;
  lastError: TalerErrorDetail | undefined;
}

/**
 * The wallet should check whether coins from this exchange
 * need to be auto-refreshed.
 */
export interface PendingExchangeCheckRefreshTask {
  type: PendingTaskType.ExchangeCheckRefresh;
  exchangeBaseUrl: string;
}

/**
 * A purchase needs to be processed (i.e. for download / payment / refund).
 */
export interface PendingPurchaseTask {
  type: PendingTaskType.Purchase;
  proposalId: string;
  retryInfo?: RetryInfo;
  /**
   * Status of the payment as string, used only for debugging.
   */
  statusStr: string;
  lastError: TalerErrorDetail | undefined;
}

/**
 * Status of an ongoing withdrawal operation.
 */
export interface PendingRefreshTask {
  type: PendingTaskType.Refresh;
  lastError?: TalerErrorDetail;
  refreshGroupId: string;
  finishedPerCoin: boolean[];
  retryInfo?: RetryInfo;
}

/**
 * The wallet is picking up a tip that the user has accepted.
 */
export interface PendingTipPickupTask {
  type: PendingTaskType.TipPickup;
  tipId: string;
  merchantBaseUrl: string;
  merchantTipId: string;
}

/**
 * Status of an ongoing withdrawal operation.
 */
export interface PendingWithdrawTask {
  type: PendingTaskType.Withdraw;
  lastError: TalerErrorDetail | undefined;
  retryInfo?: RetryInfo;
  withdrawalGroupId: string;
}

export interface PendingRecoupTask {
  type: PendingTaskType.Recoup;
  recoupGroupId: string;
  retryInfo?: RetryInfo;
  lastError: TalerErrorDetail | undefined;
}

/**
 * Status of an ongoing deposit operation.
 */
export interface PendingDepositTask {
  type: PendingTaskType.Deposit;
  lastError: TalerErrorDetail | undefined;
  retryInfo: RetryInfo | undefined;
  depositGroupId: string;
}

export interface PendingBackupTask {
  type: PendingTaskType.Backup;
  backupProviderBaseUrl: string;
  lastError: TalerErrorDetail | undefined;
}

/**
 * The wallet wants to send a peer push payment.
 */
export interface PendingPeerPushInitiationTask {
  type: PendingTaskType.PeerPushInitiation;
  pursePub: string;
}

/**
 * The wallet wants to send a peer pull payment.
 */
export interface PendingPeerPullInitiationTask {
  type: PendingTaskType.PeerPullInitiation;
  pursePub: string;
}

/**
 * The wallet wants to send a peer pull payment.
 */
export interface PendingPeerPullDebitTask {
  type: PendingTaskType.PeerPullDebit;
  peerPullPaymentIncomingId: string;
}

/**
 */
export interface PendingPeerPushCreditTask {
  type: PendingTaskType.PeerPushCredit;
  peerPushPaymentIncomingId: string;
}

10.2.69. DumpCoinsOp

/**
 * Dump all coins of the wallet in a simple JSON format.
 */
export type DumpCoinsOp = {
  op: WalletApiOperation.DumpCoins;
  request: EmptyObject;
  response: CoinDumpJson;
};
// DumpCoins = "dumpCoins"

/**
 * Easy to process format for the public data of coins
 * managed by the wallet.
 */
export interface CoinDumpJson {
  coins: Array<{
    /**
     * The coin's denomination's public key.
     */
    denom_pub: DenominationPubKey;
    /**
     * Hash of denom_pub.
     */
    denom_pub_hash: string;
    /**
     * Value of the denomination (without any fees).
     */
    denom_value: string;
    /**
     * Public key of the coin.
     */
    coin_pub: string;
    /**
     * Base URL of the exchange for the coin.
     */
    exchange_base_url: string;
    /**
     * Public key of the parent coin.
     * Only present if this coin was obtained via refreshing.
     */
    refresh_parent_coin_pub: string | undefined;
    /**
     * Public key of the reserve for this coin.
     * Only present if this coin was obtained via refreshing.
     */
    withdrawal_reserve_pub: string | undefined;
    coin_status: CoinStatus;
    spend_allocation:
      | {
          id: string;
          amount: string;
        }
      | undefined;
    /**
     * Information about the age restriction
     */
    ageCommitmentProof: AgeCommitmentProof | undefined;
  }>;
}

export type DenominationPubKey = RsaDenominationPubKey | CsDenominationPubKey;

export interface RsaDenominationPubKey {
  readonly cipher: DenomKeyType.Rsa;
  readonly rsa_public_key: string;
  readonly age_mask: number;
}

export interface CsDenominationPubKey {
  readonly cipher: DenomKeyType.ClauseSchnorr;
  readonly age_mask: number;
  readonly cs_public_key: string;
}

/**
 * Status of a coin.
 */
export declare enum CoinStatus {
  /**
   * Withdrawn and never shown to anybody.
   */
  Fresh = "fresh",
  /**
   * Fresh, but currently marked as "suspended", thus won't be used
   * for spending.  Used for testing.
   */
  FreshSuspended = "fresh-suspended",
  /**
   * A coin that has been spent and refreshed.
   */
  Dormant = "dormant",
}

export interface AgeCommitmentProof {
  commitment: AgeCommitment;
  proof: AgeProof;
}

export interface AgeCommitment {
  mask: number;
  /**
   * Public keys, one for each age group specified in the age mask.
   */
  publicKeys: Edx25519PublicKeyEnc[];
}

export type Edx25519PublicKeyEnc = FlavorP<string, "Edx25519PublicKeyEnc", 32>;

export type FlavorP<T, FlavorT extends string, S extends number> = T & {
  _flavor?: `taler.${FlavorT}`;
  _size?: S;
};

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[];
}

export type Edx25519PrivateKeyEnc = FlavorP<
  string,
  "Edx25519PrivateKeyEnc",
  64
>;

10.2.70. SetCoinSuspendedOp

/**
 * 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"

export interface SetCoinSuspendedRequest {
  coinPub: string;
  suspended: boolean;
}

10.2.71. ForceRefreshOp

/**
 * Force a refresh on coins where it would not
 * be necessary.
 */
export type ForceRefreshOp = {
  op: WalletApiOperation.ForceRefresh;
  request: ForceRefreshRequest;
  response: EmptyObject;
};
// ForceRefresh = "forceRefresh"

export interface ForceRefreshRequest {
  coinPubList: string[];
}

10.3. Common Declarations

export interface WalletCoreVersion {
  hash: string | undefined;
  version: string;
  exchange: string;
  merchant: string;
  bank: string;
  devMode: boolean;
}

export type Transaction =
  | TransactionWithdrawal
  | TransactionPayment
  | TransactionRefund
  | TransactionTip
  | TransactionRefresh
  | TransactionDeposit
  | TransactionPeerPullCredit
  | TransactionPeerPullDebit
  | TransactionPeerPushCredit
  | TransactionPeerPushDebit;

export interface TransactionWithdrawal extends TransactionCommon {
  type: TransactionType.Withdrawal;
  /**
   * Exchange of the withdrawal.
   */
  exchangeBaseUrl: string;
  /**
   * Amount that got subtracted from the reserve balance.
   */
  amountRaw: AmountString;
  /**
   * Amount that actually was (or will be) added to the wallet's balance.
   */
  amountEffective: AmountString;
  withdrawalDetails: WithdrawalDetails;
}

export interface TransactionCommon {
  transactionId: TransactionIdStr;
  type: TransactionType;
  timestamp: TalerProtocolTimestamp;
  extendedStatus: ExtendedStatus;
  /**
   * true if the transaction is still pending, false otherwise
   * If a transaction is not longer pending, its timestamp will be updated,
   * but its transactionId will remain unchanged
   *
   * @deprecated show extendedStatus
   */
  pending: boolean;
  /**
   * True if the transaction encountered a problem that might be
   * permanent.  A frozen transaction won't be automatically retried.
   *
   * @deprecated show extendedStatus
   */
  frozen: boolean;
  /**
   * Raw amount of the transaction (exclusive of fees or other extra costs).
   */
  amountRaw: AmountString;
  /**
   * Amount added or removed from the wallet's balance (including all fees and other costs).
   */
  amountEffective: AmountString;
  error?: TalerErrorDetail;
}

export declare enum TransactionType {
  Withdrawal = "withdrawal",
  Payment = "payment",
  Refund = "refund",
  Refresh = "refresh",
  Tip = "tip",
  Deposit = "deposit",
  PeerPushDebit = "peer-push-debit",
  PeerPushCredit = "peer-push-credit",
  PeerPullDebit = "peer-pull-debit",
  PeerPullCredit = "peer-pull-credit",
}

export interface TalerProtocolTimestamp {
  readonly t_s: number | "never";
}

export declare enum ExtendedStatus {
  Pending = "pending",
  Done = "done",
  Aborting = "aborting",
  Aborted = "aborted",
  Failed = "failed",
  KycRequired = "kyc-required",
}

export interface TalerErrorDetail {
  code: TalerErrorCode;
  when?: AbsoluteTime;
  hint?: string;
  [x: string]: unknown;
}

export interface AbsoluteTime {
  /**
   * Timestamp in milliseconds.
   */
  readonly t_ms: number | "never";
}

export interface Duration {
  /**
   * Duration in milliseconds.
   */
  readonly d_ms: number | "forever";
}

export interface TalerProtocolDuration {
  readonly d_us: number | "forever";
}

export type WithdrawalDetails =
  | WithdrawalDetailsForManualTransfer
  | WithdrawalDetailsForTalerBankIntegrationApi;

interface WithdrawalDetailsForManualTransfer {
  type: WithdrawalType.ManualTransfer;
  /**
   * Payto URIs that the exchange supports.
   *
   * Already contains the amount and message.
   */
  exchangePaytoUris: string[];
  reservePub: string;
  /**
   * Is the reserve ready for withdrawal?
   */
  reserveIsReady: boolean;
}

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;
}

export interface TransactionPayment extends TransactionCommon {
  type: TransactionType.Payment;
  /**
   * Additional information about the payment.
   */
  info: OrderShortInfo;
  /**
   * Wallet-internal end-to-end identifier for the payment.
   */
  proposalId: string;
  /**
   * How far did the wallet get with processing the payment?
   *
   * @deprecated use extendedStatus
   */
  status: PaymentStatus;
  /**
   * Amount that must be paid for the contract
   */
  amountRaw: AmountString;
  /**
   * Amount that was paid, including deposit, wire and refresh fees.
   */
  amountEffective: AmountString;
  /**
   * Amount that has been refunded by the merchant
   */
  totalRefundRaw: AmountString;
  /**
   * Amount will be added to the wallet's balance after fees and refreshing
   */
  totalRefundEffective: AmountString;
  /**
   * Amount pending to be picked up
   */
  refundPending: AmountString | undefined;
  /**
   * Reference to applied refunds
   */
  refunds: RefundInfoShort[];
  /**
   * Is the wallet currently checking for a refund?
   */
  refundQueryActive: boolean;
}

export interface OrderShortInfo {
  /**
   * Order ID, uniquely identifies the order within a merchant instance
   */
  orderId: string;
  /**
   * Hash of the contract terms.
   */
  contractTermsHash: string;
  /**
   * More information about the merchant
   */
  merchant: MerchantInfo;
  /**
   * Summary of the order, given by the merchant
   */
  summary: string;
  /**
   * Map from IETF BCP 47 language tags to localized summaries
   */
  summary_i18n?: InternationalizedString;
  /**
   * List of products that are part of the order
   */
  products: Product[] | undefined;
  /**
   * Time indicating when the order should be delivered.
   * May be overwritten by individual products.
   */
  delivery_date?: TalerProtocolTimestamp;
  /**
   * Delivery location for (all!) products.
   */
  delivery_location?: Location;
  /**
   * URL of the fulfillment, given by the merchant
   */
  fulfillmentUrl?: string;
  /**
   * Plain text message that should be shown to the user
   * when the payment is complete.
   */
  fulfillmentMessage?: string;
  /**
   * Translations of fulfillmentMessage.
   */
  fulfillmentMessage_i18n?: InternationalizedString;
}

export interface MerchantInfo {
  name: string;
  jurisdiction?: Location;
  address?: Location;
  logo?: string;
  website?: string;
  email?: string;
}

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[];
}

export interface InternationalizedString {
  [lang_tag: string]: string;
}

export interface Product {
  product_id?: string;
  description: string;
  description_i18n?: {
    [lang_tag: string]: string;
  };
  quantity?: number;
  unit?: string;
  price?: AmountString;
  image?: string;
  taxes?: Tax[];
  delivery_date?: TalerProtocolTimestamp;
}

export interface Tax {
  name: string;
  tax: AmountString;
}

export declare enum PaymentStatus {
  /**
   * Explicitly aborted after timeout / failure
   */
  Aborted = "aborted",
  /**
   * Payment failed, wallet will auto-retry.
   * User should be given the option to retry now / abort.
   */
  Failed = "failed",
  /**
   * Paid successfully
   */
  Paid = "paid",
  /**
   * User accepted, payment is processing.
   */
  Accepted = "accepted",
}

export interface RefundInfoShort {
  transactionId: string;
  timestamp: TalerProtocolTimestamp;
  amountEffective: AmountString;
  amountRaw: AmountString;
}

export interface TransactionRefund extends TransactionCommon {
  type: TransactionType.Refund;
  refundedTransactionId: string;
  info: OrderShortInfo;
  /**
   * Amount pending to be picked up
   */
  refundPending: AmountString | undefined;
  amountRaw: AmountString;
  amountEffective: AmountString;
}

export interface TransactionTip extends TransactionCommon {
  type: TransactionType.Tip;
  amountRaw: AmountString;
  /**
   * More information about the merchant
   */
  amountEffective: AmountString;
  merchantBaseUrl: string;
}

/**
 * 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;
}

/**
 * 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",
  Recoup = "recoup",
  BackupRestored = "backup-restored",
  Scheduled = "scheduled",
}

/**
 * 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;
}

/**
 * Credit because we were paid for a P2P invoice we created.
 */
export interface TransactionPeerPullCredit extends TransactionCommon {
  type: TransactionType.PeerPullCredit;
  info: PeerInfoShort;
  /**
   * Exchange used.
   */
  exchangeBaseUrl: string;
  /**
   * Amount that got subtracted from the reserve balance.
   */
  amountRaw: AmountString;
  /**
   * Amount that actually was (or will be) added to the wallet's balance.
   */
  amountEffective: AmountString;
  /**
   * URI to send to the other party.
   */
  talerUri: string;
}

export interface PeerInfoShort {
  expiration: TalerProtocolTimestamp | undefined;
  summary: string | undefined;
}

/**
 * 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;
}

/**
 * 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;
}

/**
 * We sent money via a P2P payment.
 */
export interface TransactionPeerPushDebit extends TransactionCommon {
  type: TransactionType.PeerPushDebit;
  info: PeerInfoShort;
  /**
   * Exchange used.
   */
  exchangeBaseUrl: string;
  /**
   * Amount that got subtracted from the reserve balance.
   */
  amountRaw: AmountString;
  /**
   * Amount that actually was (or will be) added to the wallet's balance.
   */
  amountEffective: AmountString;
  /**
   * URI to accept the payment.
   */
  talerUri: string;
}

export interface AbortTransactionRequest {
  transactionId: string;
  /**
   * Move the payment immediately into an aborted state.
   * The UI should warn the user that this might lead
   * to money being lost.
   *
   * Defaults to false.
   */
  forceImmediateAbort?: boolean;
}

export interface ExchangeListItem {
  exchangeBaseUrl: string;
  currency: string | undefined;
  paytoUris: string[];
  tosStatus: ExchangeTosStatus;
  exchangeStatus: ExchangeEntryStatus;
  ageRestrictionOptions: number[];
  /**
   * Permanently added to the wallet, as opposed to just
   * temporarily queried.
   */
  permanent: boolean;
  /**
   * Information about the last error that occurred when trying
   * to update the exchange info.
   */
  lastUpdateErrorInfo?: OperationErrorInfo;
}

export declare enum ExchangeTosStatus {
  New = "new",
  Accepted = "accepted",
  Changed = "changed",
  NotFound = "not-found",
  Unknown = "unknown",
}

export declare enum ExchangeEntryStatus {
  Unknown = "unknown",
  Outdated = "outdated",
  Ok = "ok",
}

export interface OperationErrorInfo {
  error: TalerErrorDetail;
}

export interface ForcedDenomSel {
  denoms: {
    value: AmountString;
    count: number;
  }[];
}

/**
 * Result of a prepare pay operation.
 */
export type PreparePayResult =
  | PreparePayResultInsufficientBalance
  | PreparePayResultAlreadyConfirmed
  | PreparePayResultPaymentPossible;

export interface PreparePayResultInsufficientBalance {
  status: PreparePayResultType.InsufficientBalance;
  proposalId: string;
  contractTerms: MerchantContractTerms;
  amountRaw: string;
  noncePriv: string;
  talerUri: string;
  balanceDetails: PayMerchantInsufficientBalanceDetails;
}

/**
 * Contract terms from a merchant.
 * FIXME: Add type field!
 */
export interface MerchantContractTerms {
  /**
   * Hash of the merchant's wire details.
   */
  h_wire: string;
  /**
   * Hash of the merchant's wire details.
   */
  auto_refund?: TalerProtocolDuration;
  /**
   * Wire method the merchant wants to use.
   */
  wire_method: string;
  /**
   * Human-readable short summary of the contract.
   */
  summary: string;
  summary_i18n?: InternationalizedString;
  /**
   * Nonce used to ensure freshness.
   */
  nonce: string;
  /**
   * Total amount payable.
   */
  amount: string;
  /**
   * Auditors accepted by the merchant.
   */
  auditors: AuditorHandle[];
  /**
   * Deadline to pay for the contract.
   */
  pay_deadline: TalerProtocolTimestamp;
  /**
   * Maximum deposit fee covered by the merchant.
   */
  max_fee: string;
  /**
   * Information about the merchant.
   */
  merchant: MerchantInfo;
  /**
   * Public key of the merchant.
   */
  merchant_pub: string;
  /**
   * Time indicating when the order should be delivered.
   * May be overwritten by individual products.
   */
  delivery_date?: TalerProtocolTimestamp;
  /**
   * Delivery location for (all!) products.
   */
  delivery_location?: Location;
  /**
   * List of accepted exchanges.
   */
  exchanges: ExchangeHandle[];
  /**
   * Products that are sold in this contract.
   */
  products?: Product[];
  /**
   * Deadline for refunds.
   */
  refund_deadline: TalerProtocolTimestamp;
  /**
   * Deadline for the wire transfer.
   */
  wire_transfer_deadline: TalerProtocolTimestamp;
  /**
   * Time when the contract was generated by the merchant.
   */
  timestamp: TalerProtocolTimestamp;
  /**
   * Order id to uniquely identify the purchase within
   * one merchant instance.
   */
  order_id: string;
  /**
   * Base URL of the merchant's backend.
   */
  merchant_base_url: string;
  /**
   * Fulfillment URL to view the product or
   * delivery status.
   */
  fulfillment_url?: string;
  /**
   * URL meant to share the shopping cart.
   */
  public_reorder_url?: string;
  /**
   * Plain text fulfillment message in the merchant's default language.
   */
  fulfillment_message?: string;
  /**
   * Internationalized fulfillment messages.
   */
  fulfillment_message_i18n?: InternationalizedString;
  /**
   * Share of the wire fee that must be settled with one payment.
   */
  wire_fee_amortization?: number;
  /**
   * Maximum wire fee that the merchant agrees to pay for.
   */
  max_wire_fee?: string;
  minimum_age?: number;
  /**
   * Extra data, interpreted by the mechant only.
   */
  extra?: any;
}

export interface AuditorHandle {
  /**
   * Official name of the auditor.
   */
  name: string;
  /**
   * Master public signing key of the auditor.
   */
  auditor_pub: string;
  /**
   * Base URL of the auditor.
   */
  url: string;
}

/**
 * Information about an exchange as stored inside a
 * merchant's contract terms.
 */
export interface ExchangeHandle {
  /**
   * Master public signing key of the exchange.
   */
  master_pub: string;
  /**
   * Base URL of the exchange.
   */
  url: string;
}

/**
 * Detailed reason for why the wallet's balance is insufficient.
 */
export interface PayMerchantInsufficientBalanceDetails {
  /**
   * Amount requested by the merchant.
   */
  amountRequested: AmountString;
  /**
   * Balance of type "available" (see balance.ts for definition).
   */
  balanceAvailable: AmountString;
  /**
   * Balance of type "material" (see balance.ts for definition).
   */
  balanceMaterial: AmountString;
  /**
   * Balance of type "age-acceptable" (see balance.ts for definition).
   */
  balanceAgeAcceptable: AmountString;
  /**
   * Balance of type "merchant-acceptable" (see balance.ts for definition).
   */
  balanceMerchantAcceptable: AmountString;
  /**
   * Balance of type "merchant-depositable" (see balance.ts for definition).
   */
  balanceMerchantDepositable: AmountString;
  /**
   * If the payment would succeed without fees
   * (i.e. balanceMechantWireable >= amountRequested),
   * this field contains an estimate of the amount that would additionally
   * be required to cover the fees.
   *
   * It is not possible to give an exact value here, since it depends
   * on the coin selection for the amount that would be additionally withdrawn.
   */
  feeGapEstimate: AmountString;
}

export interface PreparePayResultAlreadyConfirmed {
  status: PreparePayResultType.AlreadyConfirmed;
  contractTerms: MerchantContractTerms;
  paid: boolean;
  amountRaw: string;
  amountEffective: string;
  contractTermsHash: string;
  proposalId: string;
  talerUri?: string;
}

/**
 * Payment is possible.
 */
export interface PreparePayResultPaymentPossible {
  status: PreparePayResultType.PaymentPossible;
  proposalId: string;
  contractTerms: MerchantContractTerms;
  contractTermsHash: string;
  amountRaw: string;
  amountEffective: string;
  noncePriv: string;
  talerUri: string;
}

/**
 * Forced coin selection for deposits/payments.
 */
export interface ForcedCoinSel {
  coins: {
    value: AmountString;
    contribution: AmountString;
  }[];
}

export interface ApplyRefundResponse {
  contractTermsHash: string;
  transactionId: string;
  proposalId: string;
  amountEffectivePaid: AmountString;
  amountRefundGranted: AmountString;
  amountRefundGone: AmountString;
  pendingAtExchange: boolean;
  info: OrderShortInfo;
}

export interface AddExchangeRequest {
  exchangeBaseUrl: string;
  forceUpdate?: boolean;
}

export interface BackupRecovery {
  walletRootPriv: string;
  providers: {
    name: string;
    url: string;
  }[];
}

/**
 * Contract terms between two wallets (as opposed to a merchant and wallet).
 */
export interface PeerContractTerms {
  amount: AmountString;
  summary: string;
  purse_expiration: TalerProtocolTimestamp;
}