534 lines
16 KiB
TypeScript
534 lines
16 KiB
TypeScript
/*
|
|
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/>
|
|
*/
|
|
|
|
/**
|
|
* Functions to compute the wallet's balance.
|
|
*
|
|
* There are multiple definition of the wallet's balance.
|
|
* We use the following terminology:
|
|
*
|
|
* - "available": Balance that the wallet believes will certainly be available
|
|
* for spending, modulo any failures of the exchange or double spending issues.
|
|
* This includes available coins *not* allocated to any
|
|
* spending/refresh/... operation. Pending withdrawals are *not* counted
|
|
* towards this balance, because they are not certain to succeed.
|
|
* Pending refreshes *are* counted towards this balance.
|
|
* This balance type is nice to show to the user, because it does not
|
|
* temporarily decrease after payment when we are waiting for refreshes
|
|
*
|
|
* - "material": Balance that the wallet believes it could spend *right now*,
|
|
* without waiting for any operations to complete.
|
|
* This balance type is important when showing "insufficient balance" error messages.
|
|
*
|
|
* - "age-acceptable": Subset of the material balance that can be spent
|
|
* with age restrictions applied.
|
|
*
|
|
* - "merchant-acceptable": Subset of the material balance that can be spent with a particular
|
|
* merchant (restricted via min age, exchange, auditor, wire_method).
|
|
*
|
|
* - "merchant-depositable": Subset of the merchant-acceptable balance that the merchant
|
|
* can accept via their supported wire methods.
|
|
*/
|
|
|
|
/**
|
|
* Imports.
|
|
*/
|
|
import {
|
|
AmountJson,
|
|
Amounts,
|
|
BalancesResponse,
|
|
canonicalizeBaseUrl,
|
|
GetBalanceDetailRequest,
|
|
Logger,
|
|
parsePaytoUri,
|
|
ScopeType,
|
|
} from "@gnu-taler/taler-util";
|
|
import {
|
|
AllowedAuditorInfo,
|
|
AllowedExchangeInfo,
|
|
RefreshGroupRecord,
|
|
WalletStoresV1,
|
|
} from "../db.js";
|
|
import { InternalWalletState } from "../internal-wallet-state.js";
|
|
import { checkLogicInvariant } from "../util/invariants.js";
|
|
import { GetReadOnlyAccess } from "../util/query.js";
|
|
import { getExchangeDetails } from "./exchanges.js";
|
|
|
|
/**
|
|
* Logger.
|
|
*/
|
|
const logger = new Logger("operations/balance.ts");
|
|
|
|
interface WalletBalance {
|
|
available: AmountJson;
|
|
pendingIncoming: AmountJson;
|
|
pendingOutgoing: AmountJson;
|
|
}
|
|
|
|
/**
|
|
* Compute the available amount that the wallet expects to get
|
|
* out of a refresh group.
|
|
*/
|
|
function computeRefreshGroupAvailableAmount(r: RefreshGroupRecord): AmountJson {
|
|
// Don't count finished refreshes, since the refresh already resulted
|
|
// in coins being added to the wallet.
|
|
let available = Amounts.zeroOfCurrency(r.currency);
|
|
if (r.timestampFinished) {
|
|
return available;
|
|
}
|
|
for (let i = 0; i < r.oldCoinPubs.length; i++) {
|
|
const session = r.refreshSessionPerCoin[i];
|
|
if (session) {
|
|
// We are always assuming the refresh will succeed, thus we
|
|
// report the output as available balance.
|
|
available = Amounts.add(available, session.amountRefreshOutput).amount;
|
|
} else {
|
|
available = Amounts.add(available, r.estimatedOutputPerCoin[i]).amount;
|
|
}
|
|
}
|
|
return available;
|
|
}
|
|
|
|
/**
|
|
* Get balance information.
|
|
*/
|
|
export async function getBalancesInsideTransaction(
|
|
ws: InternalWalletState,
|
|
tx: GetReadOnlyAccess<{
|
|
coins: typeof WalletStoresV1.coins;
|
|
coinAvailability: typeof WalletStoresV1.coinAvailability;
|
|
refreshGroups: typeof WalletStoresV1.refreshGroups;
|
|
withdrawalGroups: typeof WalletStoresV1.withdrawalGroups;
|
|
}>,
|
|
): Promise<BalancesResponse> {
|
|
const balanceStore: Record<string, WalletBalance> = {};
|
|
|
|
/**
|
|
* Add amount to a balance field, both for
|
|
* the slicing by exchange and currency.
|
|
*/
|
|
const initBalance = (currency: string): WalletBalance => {
|
|
const b = balanceStore[currency];
|
|
if (!b) {
|
|
balanceStore[currency] = {
|
|
available: Amounts.zeroOfCurrency(currency),
|
|
pendingIncoming: Amounts.zeroOfCurrency(currency),
|
|
pendingOutgoing: Amounts.zeroOfCurrency(currency),
|
|
};
|
|
}
|
|
return balanceStore[currency];
|
|
};
|
|
|
|
await tx.coinAvailability.iter().forEach((ca) => {
|
|
const b = initBalance(ca.currency);
|
|
for (let i = 0; i < ca.freshCoinCount; i++) {
|
|
b.available = Amounts.add(b.available, {
|
|
currency: ca.currency,
|
|
fraction: ca.amountFrac,
|
|
value: ca.amountVal,
|
|
}).amount;
|
|
}
|
|
});
|
|
|
|
await tx.refreshGroups.iter().forEach((r) => {
|
|
const b = initBalance(r.currency);
|
|
b.available = Amounts.add(
|
|
b.available,
|
|
computeRefreshGroupAvailableAmount(r),
|
|
).amount;
|
|
});
|
|
|
|
await tx.withdrawalGroups.iter().forEach((wds) => {
|
|
if (wds.timestampFinish) {
|
|
return;
|
|
}
|
|
const b = initBalance(Amounts.currencyOf(wds.denomsSel.totalWithdrawCost));
|
|
b.pendingIncoming = Amounts.add(
|
|
b.pendingIncoming,
|
|
wds.denomsSel.totalCoinValue,
|
|
).amount;
|
|
});
|
|
|
|
const balancesResponse: BalancesResponse = {
|
|
balances: [],
|
|
};
|
|
|
|
Object.keys(balanceStore)
|
|
.sort()
|
|
.forEach((c) => {
|
|
const v = balanceStore[c];
|
|
balancesResponse.balances.push({
|
|
scopeInfo: {
|
|
type: ScopeType.Global,
|
|
currency: Amounts.currencyOf(v.available),
|
|
},
|
|
available: Amounts.stringify(v.available),
|
|
pendingIncoming: Amounts.stringify(v.pendingIncoming),
|
|
pendingOutgoing: Amounts.stringify(v.pendingOutgoing),
|
|
hasPendingTransactions: false,
|
|
requiresUserInput: false,
|
|
});
|
|
});
|
|
|
|
return balancesResponse;
|
|
}
|
|
|
|
/**
|
|
* Get detailed balance information, sliced by exchange and by currency.
|
|
*/
|
|
export async function getBalances(
|
|
ws: InternalWalletState,
|
|
): Promise<BalancesResponse> {
|
|
logger.trace("starting to compute balance");
|
|
|
|
const wbal = await ws.db
|
|
.mktx((x) => [
|
|
x.coins,
|
|
x.coinAvailability,
|
|
x.refreshGroups,
|
|
x.purchases,
|
|
x.withdrawalGroups,
|
|
])
|
|
.runReadOnly(async (tx) => {
|
|
return getBalancesInsideTransaction(ws, tx);
|
|
});
|
|
|
|
logger.trace("finished computing wallet balance");
|
|
|
|
return wbal;
|
|
}
|
|
|
|
/**
|
|
* Information about the balance for a particular payment to a particular
|
|
* merchant.
|
|
*/
|
|
export interface MerchantPaymentBalanceDetails {
|
|
balanceAvailable: AmountJson;
|
|
}
|
|
|
|
export interface MerchantPaymentRestrictionsForBalance {
|
|
currency: string;
|
|
minAge: number;
|
|
acceptedExchanges: AllowedExchangeInfo[];
|
|
acceptedAuditors: AllowedAuditorInfo[];
|
|
acceptedWireMethods: string[];
|
|
}
|
|
|
|
export interface AcceptableExchanges {
|
|
/**
|
|
* Exchanges accepted by the merchant, but wire method might not match.
|
|
*/
|
|
acceptableExchanges: string[];
|
|
|
|
/**
|
|
* Exchanges accepted by the merchant, including a matching
|
|
* wire method, i.e. the merchant can deposit coins there.
|
|
*/
|
|
depositableExchanges: string[];
|
|
}
|
|
|
|
/**
|
|
* Get all exchanges that are acceptable for a particular payment.
|
|
*/
|
|
export async function getAcceptableExchangeBaseUrls(
|
|
ws: InternalWalletState,
|
|
req: MerchantPaymentRestrictionsForBalance,
|
|
): Promise<AcceptableExchanges> {
|
|
const acceptableExchangeUrls = new Set<string>();
|
|
const depositableExchangeUrls = new Set<string>();
|
|
await ws.db
|
|
.mktx((x) => [x.exchanges, x.exchangeDetails, x.auditorTrust])
|
|
.runReadOnly(async (tx) => {
|
|
// FIXME: We should have a DB index to look up all exchanges
|
|
// for a particular auditor ...
|
|
|
|
const canonExchanges = new Set<string>();
|
|
const canonAuditors = new Set<string>();
|
|
|
|
for (const exchangeHandle of req.acceptedExchanges) {
|
|
const normUrl = canonicalizeBaseUrl(exchangeHandle.exchangeBaseUrl);
|
|
canonExchanges.add(normUrl);
|
|
}
|
|
|
|
for (const auditorHandle of req.acceptedAuditors) {
|
|
const normUrl = canonicalizeBaseUrl(auditorHandle.auditorBaseUrl);
|
|
canonAuditors.add(normUrl);
|
|
}
|
|
|
|
await tx.exchanges.iter().forEachAsync(async (exchange) => {
|
|
const dp = exchange.detailsPointer;
|
|
if (!dp) {
|
|
return;
|
|
}
|
|
const { currency, masterPublicKey } = dp;
|
|
const exchangeDetails = await tx.exchangeDetails.indexes.byPointer.get([
|
|
exchange.baseUrl,
|
|
currency,
|
|
masterPublicKey,
|
|
]);
|
|
if (!exchangeDetails) {
|
|
return;
|
|
}
|
|
|
|
let acceptable = false;
|
|
|
|
if (canonExchanges.has(exchange.baseUrl)) {
|
|
acceptableExchangeUrls.add(exchange.baseUrl);
|
|
acceptable = true;
|
|
}
|
|
for (const exchangeAuditor of exchangeDetails.auditors) {
|
|
if (canonAuditors.has(exchangeAuditor.auditor_url)) {
|
|
acceptableExchangeUrls.add(exchange.baseUrl);
|
|
acceptable = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!acceptable) {
|
|
return;
|
|
}
|
|
// FIXME: Also consider exchange and auditor public key
|
|
// instead of just base URLs?
|
|
|
|
let wireMethodSupported = false;
|
|
for (const acc of exchangeDetails.wireInfo.accounts) {
|
|
const pp = parsePaytoUri(acc.payto_uri);
|
|
checkLogicInvariant(!!pp);
|
|
for (const wm of req.acceptedWireMethods) {
|
|
if (pp.targetType === wm) {
|
|
wireMethodSupported = true;
|
|
break;
|
|
}
|
|
if (wireMethodSupported) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
acceptableExchangeUrls.add(exchange.baseUrl);
|
|
if (wireMethodSupported) {
|
|
depositableExchangeUrls.add(exchange.baseUrl);
|
|
}
|
|
});
|
|
});
|
|
return {
|
|
acceptableExchanges: [...acceptableExchangeUrls],
|
|
depositableExchanges: [...depositableExchangeUrls],
|
|
};
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
export async function getMerchantPaymentBalanceDetails(
|
|
ws: InternalWalletState,
|
|
req: MerchantPaymentRestrictionsForBalance,
|
|
): Promise<MerchantPaymentBalanceDetails> {
|
|
const acceptability = await getAcceptableExchangeBaseUrls(ws, req);
|
|
|
|
const d: MerchantPaymentBalanceDetails = {
|
|
balanceAvailable: Amounts.zeroOfCurrency(req.currency),
|
|
balanceMaterial: Amounts.zeroOfCurrency(req.currency),
|
|
balanceAgeAcceptable: Amounts.zeroOfCurrency(req.currency),
|
|
balanceMerchantAcceptable: Amounts.zeroOfCurrency(req.currency),
|
|
balanceMerchantDepositable: Amounts.zeroOfCurrency(req.currency),
|
|
};
|
|
|
|
await ws.db
|
|
.mktx((x) => [
|
|
x.coins,
|
|
x.coinAvailability,
|
|
x.refreshGroups,
|
|
x.purchases,
|
|
x.withdrawalGroups,
|
|
])
|
|
.runReadOnly(async (tx) => {
|
|
await tx.coinAvailability.iter().forEach((ca) => {
|
|
if (ca.currency != req.currency) {
|
|
return;
|
|
}
|
|
const singleCoinAmount: AmountJson = {
|
|
currency: ca.currency,
|
|
fraction: ca.amountFrac,
|
|
value: ca.amountVal,
|
|
};
|
|
const coinAmount: AmountJson = Amounts.mult(
|
|
singleCoinAmount,
|
|
ca.freshCoinCount,
|
|
).amount;
|
|
d.balanceAvailable = Amounts.add(d.balanceAvailable, coinAmount).amount;
|
|
d.balanceMaterial = Amounts.add(d.balanceMaterial, coinAmount).amount;
|
|
if (ca.maxAge === 0 || ca.maxAge > req.minAge) {
|
|
d.balanceAgeAcceptable = Amounts.add(
|
|
d.balanceAgeAcceptable,
|
|
coinAmount,
|
|
).amount;
|
|
if (acceptability.acceptableExchanges.includes(ca.exchangeBaseUrl)) {
|
|
d.balanceMerchantAcceptable = Amounts.add(
|
|
d.balanceMerchantAcceptable,
|
|
coinAmount,
|
|
).amount;
|
|
if (
|
|
acceptability.depositableExchanges.includes(ca.exchangeBaseUrl)
|
|
) {
|
|
d.balanceMerchantDepositable = Amounts.add(
|
|
d.balanceMerchantDepositable,
|
|
coinAmount,
|
|
).amount;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
await tx.refreshGroups.iter().forEach((r) => {
|
|
if (r.currency != req.currency) {
|
|
return;
|
|
}
|
|
d.balanceAvailable = Amounts.add(
|
|
d.balanceAvailable,
|
|
computeRefreshGroupAvailableAmount(r),
|
|
).amount;
|
|
});
|
|
});
|
|
|
|
return d;
|
|
}
|
|
|
|
export async function getBalanceDetail(
|
|
ws: InternalWalletState,
|
|
req: GetBalanceDetailRequest,
|
|
): Promise<MerchantPaymentBalanceDetails> {
|
|
const exchanges: { exchangeBaseUrl: string; exchangePub: string }[] = [];
|
|
const wires = new Array<string>();
|
|
await ws.db
|
|
.mktx((x) => [x.exchanges, x.exchangeDetails])
|
|
.runReadOnly(async (tx) => {
|
|
const allExchanges = await tx.exchanges.iter().toArray();
|
|
for (const e of allExchanges) {
|
|
const details = await getExchangeDetails(tx, e.baseUrl);
|
|
if (!details || req.currency !== details.currency) {
|
|
continue;
|
|
}
|
|
details.wireInfo.accounts.forEach((a) => {
|
|
const payto = parsePaytoUri(a.payto_uri);
|
|
if (payto && !wires.includes(payto.targetType)) {
|
|
wires.push(payto.targetType);
|
|
}
|
|
});
|
|
exchanges.push({
|
|
exchangePub: details.masterPublicKey,
|
|
exchangeBaseUrl: e.baseUrl,
|
|
});
|
|
}
|
|
});
|
|
|
|
return await getMerchantPaymentBalanceDetails(ws, {
|
|
currency: req.currency,
|
|
acceptedAuditors: [],
|
|
acceptedExchanges: exchanges,
|
|
acceptedWireMethods: wires,
|
|
minAge: 0,
|
|
});
|
|
}
|
|
|
|
export interface PeerPaymentRestrictionsForBalance {
|
|
currency: string;
|
|
restrictExchangeTo?: string;
|
|
}
|
|
|
|
export interface PeerPaymentBalanceDetails {
|
|
/**
|
|
* Balance of type "available" (see balance.ts for definition).
|
|
*/
|
|
balanceAvailable: AmountJson;
|
|
|
|
/**
|
|
* Balance of type "material" (see balance.ts for definition).
|
|
*/
|
|
balanceMaterial: AmountJson;
|
|
}
|
|
|
|
export async function getPeerPaymentBalanceDetailsInTx(
|
|
ws: InternalWalletState,
|
|
tx: GetReadOnlyAccess<{
|
|
coinAvailability: typeof WalletStoresV1.coinAvailability;
|
|
refreshGroups: typeof WalletStoresV1.refreshGroups;
|
|
}>,
|
|
req: PeerPaymentRestrictionsForBalance,
|
|
): Promise<PeerPaymentBalanceDetails> {
|
|
let balanceAvailable = Amounts.zeroOfCurrency(req.currency);
|
|
let balanceMaterial = Amounts.zeroOfCurrency(req.currency);
|
|
|
|
await tx.coinAvailability.iter().forEach((ca) => {
|
|
if (ca.currency != req.currency) {
|
|
return;
|
|
}
|
|
if (
|
|
req.restrictExchangeTo &&
|
|
req.restrictExchangeTo !== ca.exchangeBaseUrl
|
|
) {
|
|
return;
|
|
}
|
|
const singleCoinAmount: AmountJson = {
|
|
currency: ca.currency,
|
|
fraction: ca.amountFrac,
|
|
value: ca.amountVal,
|
|
};
|
|
const coinAmount: AmountJson = Amounts.mult(
|
|
singleCoinAmount,
|
|
ca.freshCoinCount,
|
|
).amount;
|
|
balanceAvailable = Amounts.add(balanceAvailable, coinAmount).amount;
|
|
balanceMaterial = Amounts.add(balanceMaterial, coinAmount).amount;
|
|
});
|
|
|
|
await tx.refreshGroups.iter().forEach((r) => {
|
|
balanceAvailable = Amounts.add(
|
|
balanceAvailable,
|
|
computeRefreshGroupAvailableAmount(r),
|
|
).amount;
|
|
});
|
|
|
|
return {
|
|
balanceAvailable,
|
|
balanceMaterial,
|
|
};
|
|
}
|