backup import WIP

4 files changed, 665 insertions, 26 deletions

diff --git a/packages/taler-wallet-core/src/types/backupTypes.ts b/packages/taler-wallet-core/src/types/backupTypes.ts
index d40d4fa6c..0b7f93c69 100644
--- a/packages/taler-wallet-core/src/types/backupTypes.ts
+++ b/packages/taler-wallet-core/src/types/backupTypes.ts
@@ -33,11 +33,15 @@
  *    aren't exported yet (and not even implemented in wallet-core).
  * 6. Returning money to own bank account isn't supported/exported yet.
  * 7. Peer-to-peer payments aren't supported yet.
+ * 8. Next update time / next refresh time isn't backed up yet.
  *
  * Questions:
  * 1. What happens when two backups are merged that have
  *    the same coin in different refresh groups?
  *    => Both are added, one will eventually fail
+ * 2. Should we make more information forgettable?  I.e. is
+ *    the coin selection still relevant for a purchase after the coins
+ *    are legally expired?
  *
  * General considerations / decisions:
  * 1. Information about previously occurring errors and
@@ -74,6 +78,8 @@ type DeviceIdString = string;
  */
 type ClockValue = number;
 
+type RawContractTerms = any;
+
 /**
  * Content of the backup.
  *
@@ -544,10 +550,7 @@ export interface BackupRefreshSession {
   /**
    * Hased denominations of the newly requested coins.
    */
-  new_denoms: {
-    count: number;
-    denom_pub_hash: string;
-  }[];
+  new_denoms: BackupDenomSel;
 
   /**
    * Seed used to derive the planchets and
@@ -654,10 +657,7 @@ export interface BackupWithdrawalGroup {
   /**
    * Multiset of denominations selected for withdrawal.
    */
-  selected_denoms: {
-    denom_pub_hash: string;
-    count: number;
-  }[];
+  selected_denoms: BackupDenomSel;
 }
 
 export enum BackupRefundState {
@@ -747,7 +747,14 @@ export interface BackupPurchase {
   /**
    * Contract terms we got from the merchant.
    */
-  contract_terms_raw: string;
+  contract_terms_raw: RawContractTerms;
+
+  /**
+   * Signature on the contract terms.
+   *
+   * Must be present if contract_terms_raw is present.
+   */
+  merchant_sig?: string;
 
   /**
    * Private key for the nonce.  Might eventually be used
@@ -889,6 +896,14 @@ export interface BackupDenomination {
   coins: BackupCoin[];
 }
 
+/**
+ * Denomination selection.
+ */
+export type BackupDenomSel = {
+  denom_pub_hash: string;
+  count: number;
+}[];
+
 export interface BackupReserve {
   /**
    * The reserve private key.
@@ -961,10 +976,7 @@ export interface BackupReserve {
    * Denominations selected for the initial withdrawal.
    * Stored here to show costs before withdrawal has begun.
    */
-  initial_selected_denoms: {
-    denom_pub_hash: string;
-    count: number;
-  }[];
+  initial_selected_denoms: BackupDenomSel;
 
   /**
    * Groups of withdrawal operations for this reserve.  Typically just one.
@@ -1127,10 +1139,6 @@ export enum BackupProposalStatus {
    */
   Proposed = "proposed",
   /**
-   * The user has accepted the proposal.
-   */
-  Accepted = "accepted",
-  /**
    * The user has rejected the proposal.
    */
   Refused = "refused",
@@ -1151,9 +1159,21 @@ export enum BackupProposalStatus {
  */
 export interface BackupProposal {
   /**
+   * Base URL of the merchant that proposed the purchase.
+   */
+  merchant_base_url: string;
+
+  /**
    * Downloaded data from the merchant.
    */
-  contract_terms_raw?: string;
+  contract_terms_raw?: RawContractTerms;
+
+  /**
+   * Signature on the contract terms.
+   *
+   * Must be present if contract_terms_raw is present.
+   */
+  merchant_sig?: string;
 
   /**
    * Unique ID when the order is stored in the wallet DB.
@@ -1161,6 +1181,11 @@ export interface BackupProposal {
   proposal_id: string;
 
   /**
+   * Merchant-assigned order ID of the proposal.
+   */
+  order_id: string;
+
+  /**
    * Timestamp of when the record
    * was created.
    */
diff --git a/packages/taler-wallet-core/src/types/dbTypes.ts b/packages/taler-wallet-core/src/types/dbTypes.ts
index 7ba3b8604..5b05e2874 100644
--- a/packages/taler-wallet-core/src/types/dbTypes.ts
+++ b/packages/taler-wallet-core/src/types/dbTypes.ts
@@ -753,7 +753,7 @@ export interface ProposalDownload {
   /**
    * The contract that was offered by the merchant.
    */
-  contractTermsRaw: string;
+  contractTermsRaw: any;
 
   contractData: WalletContractData;
 }
@@ -1200,14 +1200,9 @@ export interface PurchaseRecord {
   noncePub: string;
 
   /**
-   * Contract terms we got from the merchant.
+   * Downloaded and parsed proposal data.
    */
-  contractTermsRaw: string;
-
-  /**
-   * Parsed contract terms.
-   */
-  contractData: WalletContractData;
+  download: ProposalDownload;
 
   /**
    * Deposit permissions, available once the user has accepted the payment.
@@ -1291,6 +1286,9 @@ export interface ConfigRecord<T> {
   value: T;
 }
 
+/**
+ * FIXME: Eliminate this in favor of DenomSelectionState.
+ */
 export interface DenominationSelectionInfo {
   totalCoinValue: AmountJson;
   totalWithdrawCost: AmountJson;
@@ -1303,6 +1301,9 @@ export interface DenominationSelectionInfo {
   }[];
 }
 
+/**
+ * Selected denominations withn some extra info.
+ */
 export interface DenomSelectionState {
   totalCoinValue: AmountJson;
   totalWithdrawCost: AmountJson;
diff --git a/packages/taler-wallet-core/src/types/pendingTypes.ts b/packages/taler-wallet-core/src/types/pendingTypes.ts
new file mode 100644
index 000000000..18d9a2fa4
--- /dev/null
+++ b/packages/taler-wallet-core/src/types/pendingTypes.ts
@@ -0,0 +1,276 @@
+/*
+ This file is part of GNU Taler
+ (C) 2019 GNUnet e.V.
+
+ GNU Taler is free software; you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation; either version 3, or (at your option) any later version.
+
+ GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+/**
+ * Type and schema definitions for pending operations in the wallet.
+ */
+
+/**
+ * Imports.
+ */
+import { TalerErrorDetails, BalancesResponse } from "./walletTypes";
+import { ReserveRecordStatus } from "./dbTypes";
+import { Timestamp, Duration } from "../util/time";
+import { RetryInfo } from "../util/retries";
+
+export enum PendingOperationType {
+  Bug = "bug",
+  ExchangeUpdate = "exchange-update",
+  ExchangeCheckRefresh = "exchange-check-refresh",
+  Pay = "pay",
+  ProposalChoice = "proposal-choice",
+  ProposalDownload = "proposal-download",
+  Refresh = "refresh",
+  Reserve = "reserve",
+  Recoup = "recoup",
+  RefundQuery = "refund-query",
+  TipChoice = "tip-choice",
+  TipPickup = "tip-pickup",
+  Withdraw = "withdraw",
+}
+
+/**
+ * Information about a pending operation.
+ */
+export type PendingOperationInfo = PendingOperationInfoCommon &
+  (
+    | PendingBugOperation
+    | PendingExchangeUpdateOperation
+    | PendingExchangeCheckRefreshOperation
+    | PendingPayOperation
+    | PendingProposalChoiceOperation
+    | PendingProposalDownloadOperation
+    | PendingRefreshOperation
+    | PendingRefundQueryOperation
+    | PendingReserveOperation
+    | PendingTipChoiceOperation
+    | PendingTipPickupOperation
+    | PendingWithdrawOperation
+    | PendingRecoupOperation
+  );
+
+/**
+ * The wallet is currently updating information about an exchange.
+ */
+export interface PendingExchangeUpdateOperation {
+  type: PendingOperationType.ExchangeUpdate;
+  stage: ExchangeUpdateOperationStage;
+  reason: string;
+  exchangeBaseUrl: string;
+  lastError: TalerErrorDetails | undefined;
+}
+
+/**
+ * The wallet should check whether coins from this exchange
+ * need to be auto-refreshed.
+ */
+export interface PendingExchangeCheckRefreshOperation {
+  type: PendingOperationType.ExchangeCheckRefresh;
+  exchangeBaseUrl: string;
+}
+
+/**
+ * Some interal error happened in the wallet.  This pending operation
+ * should *only* be reported for problems in the wallet, not when
+ * a problem with a merchant/exchange/etc. occurs.
+ */
+export interface PendingBugOperation {
+  type: PendingOperationType.Bug;
+  message: string;
+  details: any;
+}
+
+/**
+ * Current state of an exchange update operation.
+ */
+export enum ExchangeUpdateOperationStage {
+  FetchKeys = "fetch-keys",
+  FetchWire = "fetch-wire",
+  FinalizeUpdate = "finalize-update",
+}
+
+export enum ReserveType {
+  /**
+   * Manually created.
+   */
+  Manual = "manual",
+  /**
+   * Withdrawn from a bank that has "tight" Taler integration
+   */
+  TalerBankWithdraw = "taler-bank-withdraw",
+}
+
+/**
+ * Status of processing a reserve.
+ *
+ * Does *not* include the withdrawal operation that might result
+ * from this.
+ */
+export interface PendingReserveOperation {
+  type: PendingOperationType.Reserve;
+  retryInfo: RetryInfo | undefined;
+  stage: ReserveRecordStatus;
+  timestampCreated: Timestamp;
+  reserveType: ReserveType;
+  reservePub: string;
+  bankWithdrawConfirmUrl?: string;
+}
+
+/**
+ * Status of an ongoing withdrawal operation.
+ */
+export interface PendingRefreshOperation {
+  type: PendingOperationType.Refresh;
+  lastError?: TalerErrorDetails;
+  refreshGroupId: string;
+  finishedPerCoin: boolean[];
+  retryInfo: RetryInfo;
+}
+
+/**
+ * Status of downloading signed contract terms from a merchant.
+ */
+export interface PendingProposalDownloadOperation {
+  type: PendingOperationType.ProposalDownload;
+  merchantBaseUrl: string;
+  proposalTimestamp: Timestamp;
+  proposalId: string;
+  orderId: string;
+  lastError?: TalerErrorDetails;
+  retryInfo: RetryInfo;
+}
+
+/**
+ * User must choose whether to accept or reject the merchant's
+ * proposed contract terms.
+ */
+export interface PendingProposalChoiceOperation {
+  type: PendingOperationType.ProposalChoice;
+  merchantBaseUrl: string;
+  proposalTimestamp: Timestamp;
+  proposalId: string;
+}
+
+/**
+ * The wallet is picking up a tip that the user has accepted.
+ */
+export interface PendingTipPickupOperation {
+  type: PendingOperationType.TipPickup;
+  tipId: string;
+  merchantBaseUrl: string;
+  merchantTipId: string;
+}
+
+/**
+ * The wallet has been offered a tip, and the user now needs to
+ * decide whether to accept or reject the tip.
+ */
+export interface PendingTipChoiceOperation {
+  type: PendingOperationType.TipChoice;
+  tipId: string;
+  merchantBaseUrl: string;
+  merchantTipId: string;
+}
+
+/**
+ * The wallet is signing coins and then sending them to
+ * the merchant.
+ */
+export interface PendingPayOperation {
+  type: PendingOperationType.Pay;
+  proposalId: string;
+  isReplay: boolean;
+  retryInfo: RetryInfo;
+  lastError: TalerErrorDetails | undefined;
+}
+
+/**
+ * The wallet is querying the merchant about whether any refund
+ * permissions are available for a purchase.
+ */
+export interface PendingRefundQueryOperation {
+  type: PendingOperationType.RefundQuery;
+  proposalId: string;
+  retryInfo: RetryInfo;
+  lastError: TalerErrorDetails | undefined;
+}
+
+export interface PendingRecoupOperation {
+  type: PendingOperationType.Recoup;
+  recoupGroupId: string;
+  retryInfo: RetryInfo;
+  lastError: TalerErrorDetails | undefined;
+}
+
+/**
+ * Status of an ongoing withdrawal operation.
+ */
+export interface PendingWithdrawOperation {
+  type: PendingOperationType.Withdraw;
+  lastError: TalerErrorDetails | undefined;
+  retryInfo: RetryInfo;
+  withdrawalGroupId: string;
+  numCoinsWithdrawn: number;
+  numCoinsTotal: number;
+}
+
+/**
+ * Fields that are present in every pending operation.
+ */
+export interface PendingOperationInfoCommon {
+  /**
+   * Type of the pending operation.
+   */
+  type: PendingOperationType;
+
+  /**
+   * Set to true if the operation indicates that something is really in progress,
+   * as opposed to some regular scheduled operation or a permanent failure.
+   */
+  givesLifeness: boolean;
+
+  /**
+   * Retry info, not available on all pending operations.
+   * If it is available, it must have the same name.
+   */
+  retryInfo?: RetryInfo;
+}
+
+/**
+ * Response returned from the pending operations API.
+ */
+export interface PendingOperationsResponse {
+  /**
+   * List of pending operations.
+   */
+  pendingOperations: PendingOperationInfo[];
+
+  /**
+   * Current wallet balance, including pending balances.
+   */
+  walletBalance: BalancesResponse;
+
+  /**
+   * When is the next pending operation due to be re-tried?
+   */
+  nextRetryDelay: Duration;
+
+  /**
+   * Does this response only include pending operations that
+   * are due to be executed right now?
+   */
+  onlyDue: boolean;
+}
diff --git a/packages/taler-wallet-core/src/types/transactionsTypes.ts b/packages/taler-wallet-core/src/types/transactionsTypes.ts
new file mode 100644
index 000000000..0a683f298
--- /dev/null
+++ b/packages/taler-wallet-core/src/types/transactionsTypes.ts
@@ -0,0 +1,337 @@
+/*
+ This file is part of GNU Taler
+ (C) 2019 Taler Systems S.A.
+
+ GNU Taler is free software; you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation; either version 3, or (at your option) any later version.
+
+ GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+/**
+ * Type and schema definitions for the wallet's transaction list.
+ *
+ * @author Florian Dold
+ * @author Torsten Grote
+ */
+
+/**
+ * Imports.
+ */
+import { Timestamp } from "../util/time";
+import {
+  AmountString,
+  Product,
+  InternationalizedString,
+  MerchantInfo,
+  codecForInternationalizedString,
+  codecForMerchantInfo,
+  codecForProduct,
+} from "./talerTypes";
+import {
+  Codec,
+  buildCodecForObject,
+  codecOptional,
+  codecForString,
+  codecForList,
+  codecForAny,
+} from "../util/codec";
+import { TalerErrorDetails } from "./walletTypes";
+
+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;
+}
+
+export interface TransactionsResponse {
+  // a list of past and pending transactions sorted by pending, timestamp and transactionId.
+  // In case two events are both pending and have the same timestamp,
+  // they are sorted by the transactionId
+  // (lexically ascending and locale-independent comparison).
+  transactions: Transaction[];
+}
+
+export interface TransactionCommon {
+  // opaque unique ID for the transaction, used as a starting point for paginating queries
+  // and for invoking actions on the transaction (e.g. deleting/hiding it from the history)
+  transactionId: string;
+
+  // the type of the transaction; different types might provide additional information
+  type: TransactionType;
+
+  // main timestamp of the transaction
+  timestamp: Timestamp;
+
+  // 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
+  pending: 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?: TalerErrorDetails;
+}
+
+export type Transaction =
+  | TransactionWithdrawal
+  | TransactionPayment
+  | TransactionRefund
+  | TransactionTip
+  | TransactionRefresh;
+
+export enum TransactionType {
+  Withdrawal = "withdrawal",
+  Payment = "payment",
+  Refund = "refund",
+  Refresh = "refresh",
+  Tip = "tip",
+}
+
+export enum WithdrawalType {
+  TalerBankIntegrationApi = "taler-bank-integration-api",
+  ManualTransfer = "manual-transfer",
+}
+
+export type WithdrawalDetails =
+  | WithdrawalDetailsForManualTransfer
+  | WithdrawalDetailsForTalerBankIntegrationApi;
+
+interface WithdrawalDetailsForManualTransfer {
+  type: WithdrawalType.ManualTransfer;
+
+  /**
+   * Payto URIs that the exchange supports.
+   *
+   * Already contains the amount and message.
+   */
+  exchangePaytoUris: string[];
+}
+
+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;
+}
+
+// This should only be used for actual withdrawals
+// and not for tips that have their own transactions type.
+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 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 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?
+   */
+  status: PaymentStatus;
+
+  /**
+   * Amount that must be paid for the contract
+   */
+  amountRaw: AmountString;
+
+  /**
+   * Amount that was paid, including deposit, wire and refresh fees.
+   */
+  amountEffective: AmountString;
+}
+
+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;
+
+  /**
+   * 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;
+}
+
+interface TransactionRefund extends TransactionCommon {
+  type: TransactionType.Refund;
+
+  // ID for the transaction that is refunded
+  refundedTransactionId: string;
+
+  // Additional information about the refunded payment
+  info: OrderShortInfo;
+
+  // Amount that has been refunded by the merchant
+  amountRaw: AmountString;
+
+  // Amount will be added to the wallet's balance after fees and refreshing
+  amountEffective: AmountString;
+}
+
+interface TransactionTip extends TransactionCommon {
+  type: TransactionType.Tip;
+
+  // Raw amount of the tip, without extra fees that apply
+  amountRaw: AmountString;
+
+  // Amount will be (or was) added to the wallet's balance after fees and refreshing
+  amountEffective: AmountString;
+
+  merchantBaseUrl: string;
+}
+
+// A transaction shown for refreshes that are not associated to other transactions
+// such as a refresh necessary before coin expiration.
+// It should only be returned by the API if the effective amount is different from zero.
+interface TransactionRefresh extends TransactionCommon {
+  type: TransactionType.Refresh;
+
+  // Exchange that the coins are refreshed with
+  exchangeBaseUrl: string;
+
+  // Raw amount that is refreshed
+  amountRaw: AmountString;
+
+  // Amount that will be paid as fees for the refresh
+  amountEffective: AmountString;
+}
+
+export const codecForTransactionsRequest = (): Codec<TransactionsRequest> =>
+  buildCodecForObject<TransactionsRequest>()
+    .property("currency", codecOptional(codecForString()))
+    .property("search", codecOptional(codecForString()))
+    .build("TransactionsRequest");
+
+// FIXME: do full validation here!
+export const codecForTransactionsResponse = (): Codec<TransactionsResponse> =>
+  buildCodecForObject<TransactionsResponse>()
+    .property("transactions", codecForList(codecForAny()))
+    .build("TransactionsResponse");
+
+export const codecForOrderShortInfo = (): Codec<OrderShortInfo> =>
+  buildCodecForObject<OrderShortInfo>()
+    .property("contractTermsHash", codecForString())
+    .property("fulfillmentMessage", codecOptional(codecForString()))
+    .property(
+      "fulfillmentMessage_i18n",
+      codecOptional(codecForInternationalizedString()),
+    )
+    .property("fulfillmentUrl", codecOptional(codecForString()))
+    .property("merchant", codecForMerchantInfo())
+    .property("orderId", codecForString())
+    .property("products", codecOptional(codecForList(codecForProduct())))
+    .property("summary", codecForString())
+    .property("summary_i18n", codecOptional(codecForInternationalizedString()))
+    .build("OrderShortInfo");