wallet-core: split coin selection and instructed amount conversion

1 files changed, 236 insertions, 776 deletions

diff --git a/packages/taler-wallet-core/src/util/coinSelection.ts b/packages/taler-wallet-core/src/util/coinSelection.ts
index d3c6ffc67..bb901fd75 100644
--- a/packages/taler-wallet-core/src/util/coinSelection.ts
+++ b/packages/taler-wallet-core/src/util/coinSelection.ts
@@ -31,6 +31,8 @@ import {
   AmountJson,
   AmountResponse,
   Amounts,
+  AmountString,
+  CoinPublicKeyString,
   CoinStatus,
   ConvertAmountRequest,
   DenominationInfo,
@@ -40,28 +42,28 @@ import {
   ForcedCoinSel,
   ForcedDenomSel,
   GetAmountRequest,
-  GetPlanForOperationRequest,
   j2s,
   Logger,
   parsePaytoUri,
   PayCoinSelection,
   PayMerchantInsufficientBalanceDetails,
+  PayPeerInsufficientBalanceDetails,
   strcmp,
   TransactionAmountMode,
   TransactionType,
+  UnblindedSignature,
 } from "@gnu-taler/taler-util";
 import {
   AllowedAuditorInfo,
   AllowedExchangeInfo,
   DenominationRecord,
 } from "../db.js";
-import {
-  CoinAvailabilityRecord,
-  getExchangeDetails,
-  isWithdrawableDenom,
-} from "../index.js";
+import { getExchangeDetails, isWithdrawableDenom } from "../index.js";
 import { InternalWalletState } from "../internal-wallet-state.js";
-import { getMerchantPaymentBalanceDetails } from "../operations/balance.js";
+import {
+  getMerchantPaymentBalanceDetails,
+  getPeerPaymentBalanceDetailsInTx,
+} from "../operations/balance.js";
 import { checkDbInvariant, checkLogicInvariant } from "./invariants.js";
 
 const logger = new Logger("coinSelection.ts");
@@ -255,7 +257,7 @@ export async function selectPayCoinsNew(
     wireFeeAmortization,
   } = req;
 
-  const [candidateDenoms, wireFeesPerExchange] = await selectCandidates(
+  const [candidateDenoms, wireFeesPerExchange] = await selectPayMerchantCandidates(
     ws,
     req,
   );
@@ -549,7 +551,7 @@ export type AvailableDenom = DenominationInfo & {
   numAvailable: number;
 };
 
-async function selectCandidates(
+async function selectPayMerchantCandidates(
   ws: InternalWalletState,
   req: SelectPayCoinRequestNg,
 ): Promise<[AvailableDenom[], Record<string, AmountJson>]> {
@@ -797,76 +799,6 @@ export function selectForcedWithdrawalDenominations(
   };
 }
 
-function getCoinsFilter(req: GetPlanForOperationRequest): CoinsFilter {
-  switch (req.type) {
-    case TransactionType.Withdrawal: {
-      return {
-        exchanges:
-          req.exchangeUrl === undefined ? undefined : [req.exchangeUrl],
-      };
-    }
-    case TransactionType.Deposit: {
-      const payto = parsePaytoUri(req.account);
-      if (!payto) {
-        throw Error(`wrong payto ${req.account}`);
-      }
-      return {
-        wireMethod: payto.targetType,
-      };
-    }
-  }
-}
-
-/**
- * If the operation going to be plan subtracts
- * or adds amount in the wallet db
- */
-export enum OperationType {
-  Credit = "credit",
-  Debit = "debit",
-}
-
-function getOperationType(txType: TransactionType): OperationType {
-  const operationType =
-    txType === TransactionType.Withdrawal
-      ? OperationType.Credit
-      : txType === TransactionType.Deposit
-      ? OperationType.Debit
-      : undefined;
-  if (!operationType) {
-    throw Error(`operation type ${txType} not yet supported`);
-  }
-  return operationType;
-}
-
-interface RefreshChoice {
-  /**
-   * Amount that need to be covered
-   */
-  gap: AmountJson;
-  totalFee: AmountJson;
-  selected: CoinInfo;
-  totalChangeValue: AmountJson;
-  refreshEffective: AmountJson;
-  coins: { info: CoinInfo; size: number }[];
-
-  // totalValue: AmountJson;
-  // totalDepositFee: AmountJson;
-  // totalRefreshFee: AmountJson;
-  // totalChangeContribution: AmountJson;
-  // totalChangeWithdrawalFee: AmountJson;
-}
-
-interface AvailableCoins {
-  list: CoinInfo[];
-  exchanges: Record<string, ExchangeInfo>;
-}
-interface SelectedCoins {
-  totalValue: AmountJson;
-  coins: { info: CoinInfo; size: number }[];
-  refresh?: RefreshChoice;
-}
-
 export interface CoinInfo {
   id: string;
   value: AmountJson;
@@ -880,739 +812,267 @@ export interface CoinInfo {
   exchangeBaseUrl: string;
   maxAge: number;
 }
-interface ExchangeInfo {
-  wireFee: AmountJson | undefined;
-  purseFee: AmountJson | undefined;
-  creditDeadline: AbsoluteTime;
-  debitDeadline: AbsoluteTime;
-}
-
-interface CoinsFilter {
-  shouldCalculatePurseFee?: boolean;
-  exchanges?: string[];
-  wireMethod?: string;
-  ageRestricted?: number;
-}
-/**
- * Get all the denoms that can be used for a operation that is limited
- * by the following restrictions.
- * This function is costly (by the database access) but with high chances
- * of being cached
- */
-async function getAvailableDenoms(
-  ws: InternalWalletState,
-  op: TransactionType,
-  currency: string,
-  filters: CoinsFilter = {},
-): Promise<AvailableCoins> {
-  const operationType = getOperationType(TransactionType.Deposit);
-
-  return await ws.db
-    .mktx((x) => [
-      x.exchanges,
-      x.exchangeDetails,
-      x.denominations,
-      x.coinAvailability,
-    ])
-    .runReadOnly(async (tx) => {
-      const list: CoinInfo[] = [];
-      const exchanges: Record<string, ExchangeInfo> = {};
-
-      const databaseExchanges = await tx.exchanges.iter().toArray();
-      const filteredExchanges =
-        filters.exchanges ?? databaseExchanges.map((e) => e.baseUrl);
-
-      for (const exchangeBaseUrl of filteredExchanges) {
-        const exchangeDetails = await getExchangeDetails(tx, exchangeBaseUrl);
-        // 1.- exchange has same currency
-        if (exchangeDetails?.currency !== currency) {
-          continue;
-        }
-
-        let deadline = AbsoluteTime.never();
-        // 2.- exchange supports wire method
-        let wireFee: AmountJson | undefined;
-        if (filters.wireMethod) {
-          const wireMethodWithDates =
-            exchangeDetails.wireInfo.feesForType[filters.wireMethod];
-
-          if (!wireMethodWithDates) {
-            throw Error(
-              `exchange ${exchangeBaseUrl} doesn't have wire method ${filters.wireMethod}`,
-            );
-          }
-          const wireMethodFee = wireMethodWithDates.find((x) => {
-            return AbsoluteTime.isBetween(
-              AbsoluteTime.now(),
-              AbsoluteTime.fromProtocolTimestamp(x.startStamp),
-              AbsoluteTime.fromProtocolTimestamp(x.endStamp),
-            );
-          });
-
-          if (!wireMethodFee) {
-            throw Error(
-              `exchange ${exchangeBaseUrl} doesn't have wire fee defined for this period`,
-            );
-          }
-          wireFee = Amounts.parseOrThrow(wireMethodFee.wireFee);
-          deadline = AbsoluteTime.min(
-            deadline,
-            AbsoluteTime.fromProtocolTimestamp(wireMethodFee.endStamp),
-          );
-        }
-        // exchanges[exchangeBaseUrl].wireFee = wireMethodFee;
-
-        // 3.- exchange supports wire method
-        let purseFee: AmountJson | undefined;
-        if (filters.shouldCalculatePurseFee) {
-          const purseFeeFound = exchangeDetails.globalFees.find((x) => {
-            return AbsoluteTime.isBetween(
-              AbsoluteTime.now(),
-              AbsoluteTime.fromProtocolTimestamp(x.startDate),
-              AbsoluteTime.fromProtocolTimestamp(x.endDate),
-            );
-          });
-          if (!purseFeeFound) {
-            throw Error(
-              `exchange ${exchangeBaseUrl} doesn't have purse fee defined for this period`,
-            );
-          }
-          purseFee = Amounts.parseOrThrow(purseFeeFound.purseFee);
-          deadline = AbsoluteTime.min(
-            deadline,
-            AbsoluteTime.fromProtocolTimestamp(purseFeeFound.endDate),
-          );
-        }
-
-        let creditDeadline = AbsoluteTime.never();
-        let debitDeadline = AbsoluteTime.never();
-        //4.- filter coins restricted by age
-        if (operationType === OperationType.Credit) {
-          const ds = await tx.denominations.indexes.byExchangeBaseUrl.getAll(
-            exchangeBaseUrl,
-          );
-          for (const denom of ds) {
-            const expiresWithdraw = AbsoluteTime.fromProtocolTimestamp(
-              denom.stampExpireWithdraw,
-            );
-            const expiresDeposit = AbsoluteTime.fromProtocolTimestamp(
-              denom.stampExpireDeposit,
-            );
-            creditDeadline = AbsoluteTime.min(deadline, expiresWithdraw);
-            debitDeadline = AbsoluteTime.min(deadline, expiresDeposit);
-            list.push(
-              buildCoinInfoFromDenom(
-                denom,
-                purseFee,
-                wireFee,
-                AgeRestriction.AGE_UNRESTRICTED,
-                Number.MAX_SAFE_INTEGER, // Max withdrawable from single denom
-              ),
-            );
-          }
-        } else {
-          const ageLower = filters.ageRestricted ?? 0;
-          const ageUpper = AgeRestriction.AGE_UNRESTRICTED;
-
-          const myExchangeCoins =
-            await tx.coinAvailability.indexes.byExchangeAgeAvailability.getAll(
-              GlobalIDB.KeyRange.bound(
-                [exchangeDetails.exchangeBaseUrl, ageLower, 1],
-                [
-                  exchangeDetails.exchangeBaseUrl,
-                  ageUpper,
-                  Number.MAX_SAFE_INTEGER,
-                ],
-              ),
-            );
-          //5.- save denoms with how many coins are available
-          // FIXME: Check that the individual denomination is audited!
-          // FIXME: Should we exclude denominations that are
-          // not spendable anymore?
-          for (const coinAvail of myExchangeCoins) {
-            const denom = await tx.denominations.get([
-              coinAvail.exchangeBaseUrl,
-              coinAvail.denomPubHash,
-            ]);
-            checkDbInvariant(!!denom);
-            if (denom.isRevoked || !denom.isOffered) {
-              continue;
-            }
-            const expiresWithdraw = AbsoluteTime.fromProtocolTimestamp(
-              denom.stampExpireWithdraw,
-            );
-            const expiresDeposit = AbsoluteTime.fromProtocolTimestamp(
-              denom.stampExpireDeposit,
-            );
-            creditDeadline = AbsoluteTime.min(deadline, expiresWithdraw);
-            debitDeadline = AbsoluteTime.min(deadline, expiresDeposit);
-            list.push(
-              buildCoinInfoFromDenom(
-                denom,
-                purseFee,
-                wireFee,
-                coinAvail.maxAge,
-                coinAvail.freshCoinCount,
-              ),
-            );
-          }
-        }
-
-        exchanges[exchangeBaseUrl] = {
-          purseFee,
-          wireFee,
-          debitDeadline,
-          creditDeadline,
-        };
-      }
-
-      return { list, exchanges };
-    });
-}
 
-function buildCoinInfoFromDenom(
-  denom: DenominationRecord,
-  purseFee: AmountJson | undefined,
-  wireFee: AmountJson | undefined,
-  maxAge: number,
-  total: number,
-): CoinInfo {
-  return {
-    id: denom.denomPubHash,
-    denomWithdraw: Amounts.parseOrThrow(denom.fees.feeWithdraw),
-    denomDeposit: Amounts.parseOrThrow(denom.fees.feeDeposit),
-    denomRefresh: Amounts.parseOrThrow(denom.fees.feeRefresh),
-    exchangePurse: purseFee,
-    exchangeWire: wireFee,
-    exchangeBaseUrl: denom.exchangeBaseUrl,
-    duration: AbsoluteTime.difference(
-      AbsoluteTime.now(),
-      AbsoluteTime.fromProtocolTimestamp(denom.stampExpireDeposit),
-    ),
-    totalAvailable: total,
-    value: DenominationRecord.getValue(denom),
-    maxAge,
-  };
-}
-
-export async function convertDepositAmount(
-  ws: InternalWalletState,
-  req: ConvertAmountRequest,
-): Promise<AmountResponse> {
-  const amount = Amounts.parseOrThrow(req.amount);
-  // const filter = getCoinsFilter(req);
-
-  const denoms = await getAvailableDenoms(
-    ws,
-    TransactionType.Deposit,
-    amount.currency,
-    {},
-  );
-  const result = convertDepositAmountForAvailableCoins(
-    denoms,
-    amount,
-    req.type,
-  );
 
-  return {
-    effectiveAmount: Amounts.stringify(result.effective),
-    rawAmount: Amounts.stringify(result.raw),
-  };
+export interface SelectedPeerCoin {
+  coinPub: string;
+  coinPriv: string;
+  contribution: AmountString;
+  denomPubHash: string;
+  denomSig: UnblindedSignature;
+  ageCommitmentProof: AgeCommitmentProof | undefined;
 }
 
-const LOG_REFRESH = false;
-const LOG_DEPOSIT = false;
-export function convertDepositAmountForAvailableCoins(
-  denoms: AvailableCoins,
-  amount: AmountJson,
-  mode: TransactionAmountMode,
-): AmountAndRefresh {
-  const zero = Amounts.zeroOfCurrency(amount.currency);
-  if (!denoms.list.length) {
-    // no coins in the database
-    return { effective: zero, raw: zero };
-  }
-  const depositDenoms = rankDenominationForDeposit(denoms.list, mode);
-
-  //FIXME: we are not taking into account
-  // * exchanges with multiple accounts
-  // * wallet with multiple exchanges
-  const wireFee = Object.values(denoms.exchanges)[0]?.wireFee ?? zero;
-  const adjustedAmount = Amounts.add(amount, wireFee).amount;
-
-  const selected = selectGreedyCoins(depositDenoms, adjustedAmount);
-
-  const gap = Amounts.sub(amount, selected.totalValue).amount;
-
-  const result = getTotalEffectiveAndRawForDeposit(
-    selected.coins,
-    amount.currency,
-  );
-  result.raw = Amounts.sub(result.raw, wireFee).amount;
-
-  if (Amounts.isZero(gap)) {
-    // exact amount founds
-    return result;
-  }
-
-  if (LOG_DEPOSIT) {
-    const logInfo = selected.coins.map((c) => {
-      return `${Amounts.stringifyValue(c.info.id)} x ${c.size}`;
-    });
-    console.log(
-      "deposit used:",
-      logInfo.join(", "),
-      "gap:",
-      Amounts.stringifyValue(gap),
-    );
-  }
+export interface PeerCoinSelectionDetails {
+  exchangeBaseUrl: string;
 
-  const refreshDenoms = rankDenominationForRefresh(denoms.list);
   /**
-   * FIXME: looking for refresh AFTER selecting greedy is not optimal
+   * Info of Coins that were selected.
    */
-  const refreshCoin = searchBestRefreshCoin(
-    depositDenoms,
-    refreshDenoms,
-    gap,
-    mode,
-  );
-
-  if (refreshCoin) {
-    const fee = Amounts.sub(result.effective, result.raw).amount;
-    const effective = Amounts.add(
-      result.effective,
-      refreshCoin.refreshEffective,
-    ).amount;
-    const raw = Amounts.sub(effective, fee, refreshCoin.totalFee).amount;
-    //found with change
-    return {
-      effective,
-      raw,
-      refresh: refreshCoin,
-    };
-  }
+  coins: SelectedPeerCoin[];
 
-  // there is a gap, but no refresh coin was found
-  return result;
-}
-
-export async function getMaxDepositAmount(
-  ws: InternalWalletState,
-  req: GetAmountRequest,
-): Promise<AmountResponse> {
-  // const filter = getCoinsFilter(req);
-
-  const denoms = await getAvailableDenoms(
-    ws,
-    TransactionType.Deposit,
-    req.currency,
-    {},
-  );
-
-  const result = getMaxDepositAmountForAvailableCoins(denoms, req.currency);
-  return {
-    effectiveAmount: Amounts.stringify(result.effective),
-    rawAmount: Amounts.stringify(result.raw),
-  };
+  /**
+   * How much of the deposit fees is the customer paying?
+   */
+  depositFees: AmountJson;
 }
 
-export function getMaxDepositAmountForAvailableCoins(
-  denoms: AvailableCoins,
-  currency: string,
-) {
-  const zero = Amounts.zeroOfCurrency(currency);
-  if (!denoms.list.length) {
-    // no coins in the database
-    return { effective: zero, raw: zero };
-  }
-
-  const result = getTotalEffectiveAndRawForDeposit(
-    denoms.list.map((info) => {
-      return { info, size: info.totalAvailable ?? 0 };
-    }),
-    currency,
-  );
-
-  const wireFee = Object.values(denoms.exchanges)[0]?.wireFee ?? zero;
-  result.raw = Amounts.sub(result.raw, wireFee).amount;
-
-  return result;
-}
+/**
+ * Information about a selected coin for peer to peer payments.
+ */
+export interface PeerCoinInfo {
+  /**
+   * Public key of the coin.
+   */
+  coinPub: string;
 
-export async function convertPeerPushAmount(
-  ws: InternalWalletState,
-  req: ConvertAmountRequest,
-): Promise<AmountResponse> {
-  throw Error("to be implemented after 1.0");
-}
-export async function getMaxPeerPushAmount(
-  ws: InternalWalletState,
-  req: GetAmountRequest,
-): Promise<AmountResponse> {
-  throw Error("to be implemented after 1.0");
-}
-export async function convertWithdrawalAmount(
-  ws: InternalWalletState,
-  req: ConvertAmountRequest,
-): Promise<AmountResponse> {
-  const amount = Amounts.parseOrThrow(req.amount);
+  coinPriv: string;
 
-  const denoms = await getAvailableDenoms(
-    ws,
-    TransactionType.Withdrawal,
-    amount.currency,
-    {},
-  );
+  /**
+   * Deposit fee for the coin.
+   */
+  feeDeposit: AmountJson;
 
-  const result = convertWithdrawalAmountFromAvailableCoins(
-    denoms,
-    amount,
-    req.type,
-  );
+  value: AmountJson;
 
-  return {
-    effectiveAmount: Amounts.stringify(result.effective),
-    rawAmount: Amounts.stringify(result.raw),
-  };
-}
+  denomPubHash: string;
 
-export function convertWithdrawalAmountFromAvailableCoins(
-  denoms: AvailableCoins,
-  amount: AmountJson,
-  mode: TransactionAmountMode,
-) {
-  const zero = Amounts.zeroOfCurrency(amount.currency);
-  if (!denoms.list.length) {
-    // no coins in the database
-    return { effective: zero, raw: zero };
-  }
-  const withdrawDenoms = rankDenominationForWithdrawals(denoms.list, mode);
+  denomSig: UnblindedSignature;
 
-  const selected = selectGreedyCoins(withdrawDenoms, amount);
+  maxAge: number;
 
-  return getTotalEffectiveAndRawForWithdrawal(selected.coins, amount.currency);
+  ageCommitmentProof?: AgeCommitmentProof;
 }
 
-/** *****************************************************
- * HELPERS
- * *****************************************************
- */
-
-/**
- *
- * @param depositDenoms
- * @param refreshDenoms
- * @param amount
- * @param mode
- * @returns
- */
-function searchBestRefreshCoin(
-  depositDenoms: SelectableElement[],
-  refreshDenoms: Record<string, SelectableElement[]>,
-  amount: AmountJson,
-  mode: TransactionAmountMode,
-): RefreshChoice | undefined {
-  let choice: RefreshChoice | undefined = undefined;
-  let refreshIdx = 0;
-  refreshIteration: while (refreshIdx < depositDenoms.length) {
-    const d = depositDenoms[refreshIdx];
-
-    const denomContribution =
-      mode === TransactionAmountMode.Effective
-        ? d.value
-        : Amounts.sub(d.value, d.info.denomRefresh, d.info.denomDeposit).amount;
-
-    const changeAfterDeposit = Amounts.sub(denomContribution, amount).amount;
-    if (Amounts.isZero(changeAfterDeposit)) {
-      //this coin is not big enough to use for refresh
-      //since the list is sorted, we can break here
-      break refreshIteration;
-    }
-
-    const withdrawDenoms = refreshDenoms[d.info.exchangeBaseUrl];
-    const change = selectGreedyCoins(withdrawDenoms, changeAfterDeposit);
-
-    const zero = Amounts.zeroOfCurrency(amount.currency);
-    const withdrawChangeFee = change.coins.reduce((cur, prev) => {
-      return Amounts.add(
-        cur,
-        Amounts.mult(prev.info.denomWithdraw, prev.size).amount,
-      ).amount;
-    }, zero);
-
-    const withdrawChangeValue = change.coins.reduce((cur, prev) => {
-      return Amounts.add(cur, Amounts.mult(prev.info.value, prev.size).amount)
-        .amount;
-    }, zero);
-
-    const totalFee = Amounts.add(
-      d.info.denomDeposit,
-      d.info.denomRefresh,
-      withdrawChangeFee,
-    ).amount;
+export type SelectPeerCoinsResult =
+  | { type: "success"; result: PeerCoinSelectionDetails }
+  | {
+      type: "failure";
+      insufficientBalanceDetails: PayPeerInsufficientBalanceDetails;
+    };
 
-    if (!choice || Amounts.cmp(totalFee, choice.totalFee) === -1) {
-      //found cheaper change
-      choice = {
-        gap: amount,
-        totalFee: totalFee,
-        totalChangeValue: change.totalValue, //change after refresh
-        refreshEffective: Amounts.sub(d.info.value, withdrawChangeValue).amount, // what of the denom used is not recovered
-        selected: d.info,
-        coins: change.coins,
-      };
-    }
-    refreshIdx++;
-  }
-  if (choice) {
-    if (LOG_REFRESH) {
-      const logInfo = choice.coins.map((c) => {
-        return `${Amounts.stringifyValue(c.info.id)} x ${c.size}`;
-      });
-      console.log(
-        "refresh used:",
-        Amounts.stringifyValue(choice.selected.value),
-        "change:",
-        logInfo.join(", "),
-        "fee:",
-        Amounts.stringifyValue(choice.totalFee),
-        "refreshEffective:",
-        Amounts.stringifyValue(choice.refreshEffective),
-        "totalChangeValue:",
-        Amounts.stringifyValue(choice.totalChangeValue),
-      );
-    }
-  }
-  return choice;
+export interface PeerCoinRepair {
+  exchangeBaseUrl: string;
+  coinPubs: CoinPublicKeyString[];
+  contribs: AmountJson[];
 }
 
-/**
- * Returns a copy of the list sorted for the best denom to withdraw first
- *
- * @param denoms
- * @returns
- */
-function rankDenominationForWithdrawals(
-  denoms: CoinInfo[],
-  mode: TransactionAmountMode,
-): SelectableElement[] {
-  const copyList = [...denoms];
-  /**
-   * Rank coins
-   */
-  copyList.sort((d1, d2) => {
-    // the best coin to use is
-    // 1.- the one that contrib more and pay less fee
-    // 2.- it takes more time before expires
-
-    //different exchanges may have different wireFee
-    //ranking should take the relative contribution in the exchange
-    //which is (value - denomFee / fixedFee)
-    const rate1 = Amounts.divmod(d1.value, d1.denomWithdraw).quotient;
-    const rate2 = Amounts.divmod(d2.value, d2.denomWithdraw).quotient;
-    const contribCmp = rate1 === rate2 ? 0 : rate1 < rate2 ? 1 : -1;
-    return (
-      contribCmp ||
-      Duration.cmp(d1.duration, d2.duration) ||
-      strcmp(d1.id, d2.id)
-    );
-  });
-
-  return copyList.map((info) => {
-    switch (mode) {
-      case TransactionAmountMode.Effective: {
-        //if the user instructed "effective" then we need to selected
-        //greedy total coin value
-        return {
-          info,
-          value: info.value,
-          total: Number.MAX_SAFE_INTEGER,
-        };
-      }
-      case TransactionAmountMode.Raw: {
-        //if the user instructed "raw" then we need to selected
-        //greedy total coin raw amount (without fee)
-        return {
-          info,
-          value: Amounts.add(info.value, info.denomWithdraw).amount,
-          total: Number.MAX_SAFE_INTEGER,
-        };
-      }
-    }
-  });
-}
+export interface PeerCoinSelectionRequest {
+  instructedAmount: AmountJson;
 
-/**
- * Returns a copy of the list sorted for the best denom to deposit first
- *
- * @param denoms
- * @returns
- */
-function rankDenominationForDeposit(
-  denoms: CoinInfo[],
-  mode: TransactionAmountMode,
-): SelectableElement[] {
-  const copyList = [...denoms];
   /**
-   * Rank coins
+   * Instruct the coin selection to repair this coin
+   * selection instead of selecting completely new coins.
    */
-  copyList.sort((d1, d2) => {
-    // the best coin to use is
-    // 1.- the one that contrib more and pay less fee
-    // 2.- it takes more time before expires
-
-    //different exchanges may have different wireFee
-    //ranking should take the relative contribution in the exchange
-    //which is (value - denomFee / fixedFee)
-    const rate1 = Amounts.divmod(d1.value, d1.denomDeposit).quotient;
-    const rate2 = Amounts.divmod(d2.value, d2.denomDeposit).quotient;
-    const contribCmp = rate1 === rate2 ? 0 : rate1 < rate2 ? 1 : -1;
-    return (
-      contribCmp ||
-      Duration.cmp(d1.duration, d2.duration) ||
-      strcmp(d1.id, d2.id)
-    );
-  });
-
-  return copyList.map((info) => {
-    switch (mode) {
-      case TransactionAmountMode.Effective: {
-        //if the user instructed "effective" then we need to selected
-        //greedy total coin value
-        return {
-          info,
-          value: info.value,
-          total: info.totalAvailable ?? 0,
-        };
-      }
-      case TransactionAmountMode.Raw: {
-        //if the user instructed "raw" then we need to selected
-        //greedy total coin raw amount (without fee)
-        return {
-          info,
-          value: Amounts.sub(info.value, info.denomDeposit).amount,
-          total: info.totalAvailable ?? 0,
-        };
-      }
-    }
-  });
+  repair?: PeerCoinRepair;
 }
 
-/**
- * Returns a copy of the list sorted for the best denom to withdraw first
- *
- * @param denoms
- * @returns
- */
-function rankDenominationForRefresh(
-  denoms: CoinInfo[],
-): Record<string, SelectableElement[]> {
-  const groupByExchange: Record<string, CoinInfo[]> = {};
-  for (const d of denoms) {
-    if (!groupByExchange[d.exchangeBaseUrl]) {
-      groupByExchange[d.exchangeBaseUrl] = [];
-    }
-    groupByExchange[d.exchangeBaseUrl].push(d);
-  }
-
-  const result: Record<string, SelectableElement[]> = {};
-  for (const d of denoms) {
-    result[d.exchangeBaseUrl] = rankDenominationForWithdrawals(
-      groupByExchange[d.exchangeBaseUrl],
-      TransactionAmountMode.Raw,
-    );
+export async function selectPeerCoins(
+  ws: InternalWalletState,
+  req: PeerCoinSelectionRequest,
+): Promise<SelectPeerCoinsResult> {
+  const instructedAmount = req.instructedAmount;
+  if (Amounts.isZero(instructedAmount)) {
+    // Other parts of the code assume that we have at least
+    // one coin to spend.
+    throw new Error("amount of zero not allowed");
   }
-  return result;
-}
-
-interface SelectableElement {
-  total: number;
-  value: AmountJson;
-  info: CoinInfo;
-}
-
-function selectGreedyCoins(
-  coins: SelectableElement[],
-  limit: AmountJson,
-): SelectedCoins {
-  const result: SelectedCoins = {
-    totalValue: Amounts.zeroOfCurrency(limit.currency),
-    coins: [],
-  };
-  if (!coins.length) return result;
-
-  let denomIdx = 0;
-  iterateDenoms: while (denomIdx < coins.length) {
-    const denom = coins[denomIdx];
-    // let total = denom.total;
-    const left = Amounts.sub(limit, result.totalValue).amount;
+  return await ws.db
+    .mktx((x) => [
+      x.exchanges,
+      x.contractTerms,
+      x.coins,
+      x.coinAvailability,
+      x.denominations,
+      x.refreshGroups,
+      x.peerPushPaymentInitiations,
+    ])
+    .runReadWrite(async (tx) => {
+      const exchanges = await tx.exchanges.iter().toArray();
+      const exchangeFeeGap: { [url: string]: AmountJson } = {};
+      const currency = Amounts.currencyOf(instructedAmount);
+      for (const exch of exchanges) {
+        if (exch.detailsPointer?.currency !== currency) {
+          continue;
+        }
+        // FIXME: Can't we do this faster by using coinAvailability?
+        const coins = (
+          await tx.coins.indexes.byBaseUrl.getAll(exch.baseUrl)
+        ).filter((x) => x.status === CoinStatus.Fresh);
+        const coinInfos: PeerCoinInfo[] = [];
+        for (const coin of coins) {
+          const denom = await ws.getDenomInfo(
+            ws,
+            tx,
+            coin.exchangeBaseUrl,
+            coin.denomPubHash,
+          );
+          if (!denom) {
+            throw Error("denom not found");
+          }
+          coinInfos.push({
+            coinPub: coin.coinPub,
+            feeDeposit: Amounts.parseOrThrow(denom.feeDeposit),
+            value: Amounts.parseOrThrow(denom.value),
+            denomPubHash: denom.denomPubHash,
+            coinPriv: coin.coinPriv,
+            denomSig: coin.denomSig,
+            maxAge: coin.maxAge,
+            ageCommitmentProof: coin.ageCommitmentProof,
+          });
+        }
+        if (coinInfos.length === 0) {
+          continue;
+        }
+        coinInfos.sort(
+          (o1, o2) =>
+            -Amounts.cmp(o1.value, o2.value) ||
+            strcmp(o1.denomPubHash, o2.denomPubHash),
+        );
+        let amountAcc = Amounts.zeroOfCurrency(currency);
+        let depositFeesAcc = Amounts.zeroOfCurrency(currency);
+        const resCoins: {
+          coinPub: string;
+          coinPriv: string;
+          contribution: AmountString;
+          denomPubHash: string;
+          denomSig: UnblindedSignature;
+          ageCommitmentProof: AgeCommitmentProof | undefined;
+        }[] = [];
+        let lastDepositFee = Amounts.zeroOfCurrency(currency);
+
+        if (req.repair) {
+          for (let i = 0; i < req.repair.coinPubs.length; i++) {
+            const contrib = req.repair.contribs[i];
+            const coin = await tx.coins.get(req.repair.coinPubs[i]);
+            if (!coin) {
+              throw Error("repair not possible, coin not found");
+            }
+            const denom = await ws.getDenomInfo(
+              ws,
+              tx,
+              coin.exchangeBaseUrl,
+              coin.denomPubHash,
+            );
+            checkDbInvariant(!!denom);
+            resCoins.push({
+              coinPriv: coin.coinPriv,
+              coinPub: coin.coinPub,
+              contribution: Amounts.stringify(contrib),
+              denomPubHash: coin.denomPubHash,
+              denomSig: coin.denomSig,
+              ageCommitmentProof: coin.ageCommitmentProof,
+            });
+            const depositFee = Amounts.parseOrThrow(denom.feeDeposit);
+            lastDepositFee = depositFee;
+            amountAcc = Amounts.add(
+              amountAcc,
+              Amounts.sub(contrib, depositFee).amount,
+            ).amount;
+            depositFeesAcc = Amounts.add(depositFeesAcc, depositFee).amount;
+          }
+        }
 
-    if (Amounts.isZero(denom.value)) {
-      // 0 contribution denoms should be the last
-      break iterateDenoms;
-    }
+        for (const coin of coinInfos) {
+          if (Amounts.cmp(amountAcc, instructedAmount) >= 0) {
+            break;
+          }
+          const gap = Amounts.add(
+            coin.feeDeposit,
+            Amounts.sub(instructedAmount, amountAcc).amount,
+          ).amount;
+          const contrib = Amounts.min(gap, coin.value);
+          amountAcc = Amounts.add(
+            amountAcc,
+            Amounts.sub(contrib, coin.feeDeposit).amount,
+          ).amount;
+          depositFeesAcc = Amounts.add(depositFeesAcc, coin.feeDeposit).amount;
+          resCoins.push({
+            coinPriv: coin.coinPriv,
+            coinPub: coin.coinPub,
+            contribution: Amounts.stringify(contrib),
+            denomPubHash: coin.denomPubHash,
+            denomSig: coin.denomSig,
+            ageCommitmentProof: coin.ageCommitmentProof,
+          });
+          lastDepositFee = coin.feeDeposit;
+        }
+        if (Amounts.cmp(amountAcc, instructedAmount) >= 0) {
+          const res: PeerCoinSelectionDetails = {
+            exchangeBaseUrl: exch.baseUrl,
+            coins: resCoins,
+            depositFees: depositFeesAcc,
+          };
+          return { type: "success", result: res };
+        }
+        const diff = Amounts.sub(instructedAmount, amountAcc).amount;
+        exchangeFeeGap[exch.baseUrl] = Amounts.add(lastDepositFee, diff).amount;
 
-    //use Amounts.divmod instead of iterate
-    const div = Amounts.divmod(left, denom.value);
-    const size = Math.min(div.quotient, denom.total);
-    if (size > 0) {
-      const mul = Amounts.mult(denom.value, size).amount;
-      const progress = Amounts.add(result.totalValue, mul).amount;
+        continue;
+      }
 
-      result.totalValue = progress;
-      result.coins.push({ info: denom.info, size });
-      denom.total = denom.total - size;
-    }
+      // We were unable to select coins.
+      // Now we need to produce error details.
 
-    //go next denom
-    denomIdx++;
-  }
+      const infoGeneral = await getPeerPaymentBalanceDetailsInTx(ws, tx, {
+        currency,
+      });
 
-  return result;
-}
+      const perExchange: PayPeerInsufficientBalanceDetails["perExchange"] = {};
 
-type AmountWithFee = { raw: AmountJson; effective: AmountJson };
-type AmountAndRefresh = AmountWithFee & { refresh?: RefreshChoice };
+      let maxFeeGapEstimate = Amounts.zeroOfCurrency(currency);
 
-export function getTotalEffectiveAndRawForDeposit(
-  list: { info: CoinInfo; size: number }[],
-  currency: string,
-): AmountWithFee {
-  const init = {
-    raw: Amounts.zeroOfCurrency(currency),
-    effective: Amounts.zeroOfCurrency(currency),
-  };
-  return list.reduce((prev, cur) => {
-    const ef = Amounts.mult(cur.info.value, cur.size).amount;
-    const rw = Amounts.mult(
-      Amounts.sub(cur.info.value, cur.info.denomDeposit).amount,
-      cur.size,
-    ).amount;
+      for (const exch of exchanges) {
+        if (exch.detailsPointer?.currency !== currency) {
+          continue;
+        }
+        const infoExchange = await getPeerPaymentBalanceDetailsInTx(ws, tx, {
+          currency,
+          restrictExchangeTo: exch.baseUrl,
+        });
+        let gap =
+          exchangeFeeGap[exch.baseUrl] ?? Amounts.zeroOfCurrency(currency);
+        if (Amounts.cmp(infoExchange.balanceMaterial, instructedAmount) < 0) {
+          // Show fee gap only if we should've been able to pay with the material amount
+          gap = Amounts.zeroOfCurrency(currency);
+        }
+        perExchange[exch.baseUrl] = {
+          balanceAvailable: Amounts.stringify(infoExchange.balanceAvailable),
+          balanceMaterial: Amounts.stringify(infoExchange.balanceMaterial),
+          feeGapEstimate: Amounts.stringify(gap),
+        };
 
-    prev.effective = Amounts.add(prev.effective, ef).amount;
-    prev.raw = Amounts.add(prev.raw, rw).amount;
-    return prev;
-  }, init);
-}
+        maxFeeGapEstimate = Amounts.max(maxFeeGapEstimate, gap);
+      }
 
-function getTotalEffectiveAndRawForWithdrawal(
-  list: { info: CoinInfo; size: number }[],
-  currency: string,
-): AmountWithFee {
-  const init = {
-    raw: Amounts.zeroOfCurrency(currency),
-    effective: Amounts.zeroOfCurrency(currency),
-  };
-  return list.reduce((prev, cur) => {
-    const ef = Amounts.mult(cur.info.value, cur.size).amount;
-    const rw = Amounts.mult(
-      Amounts.add(cur.info.value, cur.info.denomWithdraw).amount,
-      cur.size,
-    ).amount;
+      const errDetails: PayPeerInsufficientBalanceDetails = {
+        amountRequested: Amounts.stringify(instructedAmount),
+        balanceAvailable: Amounts.stringify(infoGeneral.balanceAvailable),
+        balanceMaterial: Amounts.stringify(infoGeneral.balanceMaterial),
+        feeGapEstimate: Amounts.stringify(maxFeeGapEstimate),
+        perExchange,
+      };
 
-    prev.effective = Amounts.add(prev.effective, ef).amount;
-    prev.raw = Amounts.add(prev.raw, rw).amount;
-    return prev;
-  }, init);
+      return { type: "failure", insufficientBalanceDetails: errDetails };
+    });
 }