/*
This file is part of TALER
(C) 2015-2019 GNUnet e.V.
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.
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
TALER; see the file COPYING. If not, see
*/
/**
* High-level wallet operations that should be indepentent from the underlying
* browser extension interface.
*/
/**
* Imports.
*/
import { CryptoApi, CryptoWorkerFactory } from "./crypto/cryptoApi";
import {
amountToPretty,
canonicalJson,
canonicalizeBaseUrl,
getTalerStampSec,
strcmp,
extractTalerStamp,
extractTalerStampOrThrow,
} from "./helpers";
import { HttpRequestLibrary } from "./http";
import * as LibtoolVersion from "./libtoolVersion";
import {
TransactionAbort,
oneShotPut,
oneShotGet,
runWithWriteTransaction,
oneShotIter,
oneShotIterIndex,
oneShotGetIndexed,
oneShotMutate,
} from "./query";
import { AmountJson } from "./amounts";
import * as Amounts from "./amounts";
import URI = require("urijs");
import {
CoinRecord,
CoinStatus,
CoinsReturnRecord,
CurrencyRecord,
DenominationRecord,
DenominationStatus,
ExchangeRecord,
PlanchetRecord,
ProposalRecord,
PurchaseRecord,
RefreshPlanchetRecord,
RefreshSessionRecord,
ReserveRecord,
Stores,
TipRecord,
WireFee,
WithdrawalSessionRecord,
ExchangeUpdateStatus,
ReserveRecordStatus,
ProposalStatus,
} from "./dbTypes";
import {
Auditor,
ContractTerms,
Denomination,
ExchangeHandle,
ExchangeWireJson,
KeysJson,
MerchantRefundPermission,
MerchantRefundResponse,
PayReq,
PaybackConfirmation,
Proposal,
RefundRequest,
ReserveStatus,
TipPlanchetDetail,
TipResponse,
WithdrawOperationStatusResponse,
TipPickupGetResponse,
} from "./talerTypes";
import {
Badge,
BenchmarkResult,
CoinSelectionResult,
CoinWithDenom,
ConfirmPayResult,
ConfirmReserveRequest,
CreateReserveRequest,
CreateReserveResponse,
HistoryEvent,
NextUrlResult,
Notifier,
PayCoinInfo,
ReserveCreationInfo,
ReturnCoinsRequest,
SenderWireInfos,
TipStatus,
WalletBalance,
WalletBalanceEntry,
PreparePayResult,
DownloadedWithdrawInfo,
WithdrawDetails,
AcceptWithdrawalResponse,
PurchaseDetails,
PendingOperationInfo,
PendingOperationsResponse,
HistoryQuery,
getTimestampNow,
OperationError,
Timestamp,
} from "./walletTypes";
import {
parsePayUri,
parseWithdrawUri,
parseTipUri,
parseRefundUri,
} from "./taleruri";
import { Logger } from "./logging";
import { randomBytes } from "./crypto/primitives/nacl-fast";
import { encodeCrock, getRandomBytes } from "./crypto/talerCrypto";
interface SpeculativePayData {
payCoinInfo: PayCoinInfo;
exchangeUrl: string;
orderDownloadId: string;
proposal: ProposalRecord;
}
/**
* Wallet protocol version spoken with the exchange
* and merchant.
*
* Uses libtool's current:revision:age versioning.
*/
export const WALLET_PROTOCOL_VERSION = "3:0:0";
const WALLET_CACHE_BREAKER_CLIENT_VERSION = "2";
const builtinCurrencies: CurrencyRecord[] = [
{
auditors: [
{
auditorPub: "BW9DC48PHQY4NH011SHHX36DZZ3Q22Y6X7FZ1VD1CMZ2PTFZ6PN0",
baseUrl: "https://auditor.demo.taler.net/",
expirationStamp: new Date(2027, 1).getTime(),
},
],
exchanges: [],
fractionalDigits: 2,
name: "KUDOS",
},
];
function isWithdrawableDenom(d: DenominationRecord) {
const now = getTimestampNow();
const started = now.t_ms >= d.stampStart.t_ms;
const stillOkay = d.stampExpireWithdraw.t_ms + 60 * 1000 > now.t_ms;
return started && stillOkay;
}
interface SelectPayCoinsResult {
cds: CoinWithDenom[];
totalFees: AmountJson;
}
function assertUnreachable(x: never): never {
throw new Error("Didn't expect to get here");
}
/**
* Get the amount that we lose when refreshing a coin of the given denomination
* with a certain amount left.
*
* If the amount left is zero, then the refresh cost
* is also considered to be zero. If a refresh isn't possible (e.g. due to lack of
* the right denominations), then the cost is the full amount left.
*
* Considers refresh fees, withdrawal fees after refresh and amounts too small
* to refresh.
*/
export function getTotalRefreshCost(
denoms: DenominationRecord[],
refreshedDenom: DenominationRecord,
amountLeft: AmountJson,
): AmountJson {
const withdrawAmount = Amounts.sub(amountLeft, refreshedDenom.feeRefresh)
.amount;
const withdrawDenoms = getWithdrawDenomList(withdrawAmount, denoms);
const resultingAmount = Amounts.add(
Amounts.getZero(withdrawAmount.currency),
...withdrawDenoms.map(d => d.value),
).amount;
const totalCost = Amounts.sub(amountLeft, resultingAmount).amount;
Wallet.enableTracing &&
console.log(
"total refresh cost for",
amountToPretty(amountLeft),
"is",
amountToPretty(totalCost),
);
return totalCost;
}
/**
* Select coins for a payment under the merchant's constraints.
*
* @param denoms all available denoms, used to compute refresh fees
*/
export function selectPayCoins(
denoms: DenominationRecord[],
cds: CoinWithDenom[],
paymentAmount: AmountJson,
depositFeeLimit: AmountJson,
): SelectPayCoinsResult | undefined {
if (cds.length === 0) {
return undefined;
}
// Sort by ascending deposit fee and denomPub if deposit fee is the same
// (to guarantee deterministic results)
cds.sort(
(o1, o2) =>
Amounts.cmp(o1.denom.feeDeposit, o2.denom.feeDeposit) ||
strcmp(o1.denom.denomPub, o2.denom.denomPub),
);
const currency = cds[0].denom.value.currency;
const cdsResult: CoinWithDenom[] = [];
let accDepositFee: AmountJson = Amounts.getZero(currency);
let accAmount: AmountJson = Amounts.getZero(currency);
for (const { coin, denom } of cds) {
if (coin.suspended) {
continue;
}
if (coin.status !== CoinStatus.Fresh) {
continue;
}
if (Amounts.cmp(denom.feeDeposit, coin.currentAmount) >= 0) {
continue;
}
cdsResult.push({ coin, denom });
accDepositFee = Amounts.add(denom.feeDeposit, accDepositFee).amount;
let leftAmount = Amounts.sub(
coin.currentAmount,
Amounts.sub(paymentAmount, accAmount).amount,
).amount;
accAmount = Amounts.add(coin.currentAmount, accAmount).amount;
const coversAmount = Amounts.cmp(accAmount, paymentAmount) >= 0;
const coversAmountWithFee =
Amounts.cmp(
accAmount,
Amounts.add(paymentAmount, denom.feeDeposit).amount,
) >= 0;
const isBelowFee = Amounts.cmp(accDepositFee, depositFeeLimit) <= 0;
Wallet.enableTracing &&
console.log("candidate coin selection", {
coversAmount,
isBelowFee,
accDepositFee,
accAmount,
paymentAmount,
});
if ((coversAmount && isBelowFee) || coversAmountWithFee) {
const depositFeeToCover = Amounts.sub(accDepositFee, depositFeeLimit)
.amount;
leftAmount = Amounts.sub(leftAmount, depositFeeToCover).amount;
Wallet.enableTracing &&
console.log("deposit fee to cover", amountToPretty(depositFeeToCover));
let totalFees: AmountJson = Amounts.getZero(currency);
if (coversAmountWithFee && !isBelowFee) {
// these are the fees the customer has to pay
// because the merchant doesn't cover them
totalFees = Amounts.sub(depositFeeLimit, accDepositFee).amount;
}
totalFees = Amounts.add(
totalFees,
getTotalRefreshCost(denoms, denom, leftAmount),
).amount;
return { cds: cdsResult, totalFees };
}
}
return undefined;
}
/**
* Get a list of denominations (with repetitions possible)
* whose total value is as close as possible to the available
* amount, but never larger.
*/
function getWithdrawDenomList(
amountAvailable: AmountJson,
denoms: DenominationRecord[],
): DenominationRecord[] {
let remaining = Amounts.copy(amountAvailable);
const ds: DenominationRecord[] = [];
denoms = denoms.filter(isWithdrawableDenom);
denoms.sort((d1, d2) => Amounts.cmp(d2.value, d1.value));
// This is an arbitrary number of coins
// we can withdraw in one go. It's not clear if this limit
// is useful ...
for (let i = 0; i < 1000; i++) {
let found = false;
for (const d of denoms) {
const cost = Amounts.add(d.value, d.feeWithdraw).amount;
if (Amounts.cmp(remaining, cost) < 0) {
continue;
}
found = true;
remaining = Amounts.sub(remaining, cost).amount;
ds.push(d);
break;
}
if (!found) {
break;
}
}
return ds;
}
interface CoinsForPaymentArgs {
allowedAuditors: Auditor[];
allowedExchanges: ExchangeHandle[];
depositFeeLimit: AmountJson;
paymentAmount: AmountJson;
wireFeeAmortization: number;
wireFeeLimit: AmountJson;
wireFeeTime: Timestamp;
wireMethod: string;
}
/**
* This error is thrown when an
*/
export class OperationFailedAndReportedError extends Error {
constructor(message: string) {
super(message);
// Set the prototype explicitly.
Object.setPrototypeOf(this, OperationFailedAndReportedError.prototype);
}
}
const logger = new Logger("wallet.ts");
interface MemoEntry {
p: Promise;
t: number;
n: number;
}
class AsyncOpMemo {
n = 0;
memo: { [k: string]: MemoEntry } = {};
put(key: string, p: Promise): Promise {
const n = this.n++;
this.memo[key] = {
p,
n,
t: new Date().getTime(),
};
p.finally(() => {
const r = this.memo[key];
if (r && r.n === n) {
delete this.memo[key];
}
});
return p;
}
find(key: string): Promise | undefined {
const res = this.memo[key];
const tNow = new Date().getTime();
if (res && res.t < tNow - 10 * 1000) {
delete this.memo[key];
return;
} else if (res) {
return res.p;
}
return;
}
}
/**
* The platform-independent wallet implementation.
*/
export class Wallet {
/**
* IndexedDB database used by the wallet.
*/
db: IDBDatabase;
static enableTracing = false;
private http: HttpRequestLibrary;
private badge: Badge;
private notifier: Notifier;
private cryptoApi: CryptoApi;
private speculativePayData: SpeculativePayData | undefined;
private cachedNextUrl: { [fulfillmentUrl: string]: NextUrlResult } = {};
private memoProcessReserve = new AsyncOpMemo();
constructor(
db: IDBDatabase,
http: HttpRequestLibrary,
badge: Badge,
notifier: Notifier,
cryptoWorkerFactory: CryptoWorkerFactory,
) {
this.db = db;
this.http = http;
this.badge = badge;
this.notifier = notifier;
this.cryptoApi = new CryptoApi(cryptoWorkerFactory);
}
/**
* Execute one operation based on the pending operation info record.
*/
async processOnePendingOperation(
pending: PendingOperationInfo,
): Promise {
switch (pending.type) {
case "bug":
return;
case "dirty-coin":
await this.refresh(pending.coinPub);
break;
case "exchange-update":
await this.updateExchangeFromUrl(pending.exchangeBaseUrl);
break;
case "planchet":
await this.processPlanchet(pending.coinPub);
break;
case "refresh":
await this.processRefreshSession(pending.refreshSessionId);
break;
case "reserve":
await this.processReserve(pending.reservePub);
break;
case "withdraw":
await this.processWithdrawSession(pending.withdrawSessionId);
break;
case "proposal":
// Nothing to do, user needs to accept/reject
break;
default:
assertUnreachable(pending);
}
}
/**
* Process pending operations.
*/
public async runPending(): Promise {
const pendingOpsResponse = await this.getPendingOperations();
for (const p of pendingOpsResponse.pendingOperations) {
try {
await this.processOnePendingOperation(p);
} catch (e) {
console.error(e);
}
}
}
/**
* Process pending operations and wait for scheduled operations in
* a loop until the wallet is stopped explicitly.
*/
public async runUntilStopped(): Promise {
throw Error("not implemented");
}
/**
* Run until all coins have been withdrawn from the given reserve,
* or an error has occured.
*/
public async runUntilReserveDepleted(reservePub: string) {
while (true) {
const r = await this.getPendingOperations();
const allPending = r.pendingOperations;
const relevantPending = allPending.filter(x => {
switch (x.type) {
case "planchet":
case "reserve":
return x.reservePub === reservePub;
default:
return false;
}
});
if (relevantPending.length === 0) {
return;
}
for (const p of relevantPending) {
await this.processOnePendingOperation(p);
}
}
}
/**
* Insert the hard-coded defaults for exchanges, coins and
* auditors into the database, unless these defaults have
* already been applied.
*/
async fillDefaults() {
await runWithWriteTransaction(
this.db,
[Stores.config, Stores.currencies],
async tx => {
let applied = false;
await tx.iter(Stores.config).forEach(x => {
if (x.key == "currencyDefaultsApplied" && x.value == true) {
applied = true;
}
});
if (!applied) {
for (let c of builtinCurrencies) {
await tx.put(Stores.currencies, c);
}
}
},
);
}
private async getCoinsForReturn(
exchangeBaseUrl: string,
amount: AmountJson,
): Promise {
const exchange = await oneShotGet(
this.db,
Stores.exchanges,
exchangeBaseUrl,
);
if (!exchange) {
throw Error(`Exchange ${exchangeBaseUrl} not known to the wallet`);
}
const coins: CoinRecord[] = await oneShotIterIndex(
this.db,
Stores.coins.exchangeBaseUrlIndex,
exchange.baseUrl,
).toArray();
if (!coins || !coins.length) {
return [];
}
const denoms = await oneShotIterIndex(
this.db,
Stores.denominations.exchangeBaseUrlIndex,
exchange.baseUrl,
).toArray();
// Denomination of the first coin, we assume that all other
// coins have the same currency
const firstDenom = await oneShotGet(this.db, Stores.denominations, [
exchange.baseUrl,
coins[0].denomPub,
]);
if (!firstDenom) {
throw Error("db inconsistent");
}
const currency = firstDenom.value.currency;
const cds: CoinWithDenom[] = [];
for (const coin of coins) {
const denom = await oneShotGet(this.db, Stores.denominations, [
exchange.baseUrl,
coin.denomPub,
]);
if (!denom) {
throw Error("db inconsistent");
}
if (denom.value.currency !== currency) {
console.warn(
`same pubkey for different currencies at exchange ${exchange.baseUrl}`,
);
continue;
}
if (coin.suspended) {
continue;
}
if (coin.status !== CoinStatus.Fresh) {
continue;
}
cds.push({ coin, denom });
}
const res = selectPayCoins(denoms, cds, amount, amount);
if (res) {
return res.cds;
}
return undefined;
}
/**
* Get exchanges and associated coins that are still spendable, but only
* if the sum the coins' remaining value covers the payment amount and fees.
*/
private async getCoinsForPayment(
args: CoinsForPaymentArgs,
): Promise {
const {
allowedAuditors,
allowedExchanges,
depositFeeLimit,
paymentAmount,
wireFeeAmortization,
wireFeeLimit,
wireFeeTime,
wireMethod,
} = args;
let remainingAmount = paymentAmount;
const exchanges = await oneShotIter(this.db, Stores.exchanges).toArray();
for (const exchange of exchanges) {
let isOkay: boolean = false;
const exchangeDetails = exchange.details;
if (!exchangeDetails) {
continue;
}
const exchangeFees = exchange.wireInfo;
if (!exchangeFees) {
continue;
}
// is the exchange explicitly allowed?
for (const allowedExchange of allowedExchanges) {
if (allowedExchange.master_pub === exchangeDetails.masterPublicKey) {
isOkay = true;
break;
}
}
// is the exchange allowed because of one of its auditors?
if (!isOkay) {
for (const allowedAuditor of allowedAuditors) {
for (const auditor of exchangeDetails.auditors) {
if (auditor.auditor_pub === allowedAuditor.auditor_pub) {
isOkay = true;
break;
}
}
if (isOkay) {
break;
}
}
}
if (!isOkay) {
continue;
}
const coins = await oneShotIterIndex(
this.db,
Stores.coins.exchangeBaseUrlIndex,
exchange.baseUrl,
).toArray();
const denoms = await oneShotIterIndex(
this.db,
Stores.denominations.exchangeBaseUrlIndex,
exchange.baseUrl,
).toArray();
if (!coins || coins.length === 0) {
continue;
}
// Denomination of the first coin, we assume that all other
// coins have the same currency
const firstDenom = await oneShotGet(this.db, Stores.denominations, [
exchange.baseUrl,
coins[0].denomPub,
]);
if (!firstDenom) {
throw Error("db inconsistent");
}
const currency = firstDenom.value.currency;
const cds: CoinWithDenom[] = [];
for (const coin of coins) {
const denom = await oneShotGet(this.db, Stores.denominations, [
exchange.baseUrl,
coin.denomPub,
]);
if (!denom) {
throw Error("db inconsistent");
}
if (denom.value.currency !== currency) {
console.warn(
`same pubkey for different currencies at exchange ${exchange.baseUrl}`,
);
continue;
}
if (coin.suspended) {
continue;
}
if (coin.status !== CoinStatus.Fresh) {
continue;
}
cds.push({ coin, denom });
}
let totalFees = Amounts.getZero(currency);
let wireFee: AmountJson | undefined;
for (const fee of exchangeFees.feesForType[wireMethod] || []) {
if (fee.startStamp <= wireFeeTime && fee.endStamp >= wireFeeTime) {
wireFee = fee.wireFee;
break;
}
}
if (wireFee) {
const amortizedWireFee = Amounts.divide(wireFee, wireFeeAmortization);
if (Amounts.cmp(wireFeeLimit, amortizedWireFee) < 0) {
totalFees = Amounts.add(amortizedWireFee, totalFees).amount;
remainingAmount = Amounts.add(amortizedWireFee, remainingAmount)
.amount;
}
}
const res = selectPayCoins(denoms, cds, remainingAmount, depositFeeLimit);
if (res) {
totalFees = Amounts.add(totalFees, res.totalFees).amount;
return {
cds: res.cds,
exchangeUrl: exchange.baseUrl,
totalAmount: remainingAmount,
totalFees,
};
}
}
return undefined;
}
/**
* Record all information that is necessary to
* pay for a proposal in the wallet's database.
*/
private async recordConfirmPay(
proposal: ProposalRecord,
payCoinInfo: PayCoinInfo,
chosenExchange: string,
): Promise {
const payReq: PayReq = {
coins: payCoinInfo.sigs,
merchant_pub: proposal.contractTerms.merchant_pub,
mode: "pay",
order_id: proposal.contractTerms.order_id,
};
const t: PurchaseRecord = {
abortDone: false,
abortRequested: false,
contractTerms: proposal.contractTerms,
contractTermsHash: proposal.contractTermsHash,
finished: false,
lastSessionId: undefined,
merchantSig: proposal.merchantSig,
payReq,
refundsDone: {},
refundsPending: {},
timestamp: getTimestampNow(),
timestamp_refund: undefined,
};
await runWithWriteTransaction(
this.db,
[Stores.coins, Stores.purchases],
async tx => {
await tx.put(Stores.purchases, t);
for (let c of payCoinInfo.updatedCoins) {
await tx.put(Stores.coins, c);
}
},
);
this.badge.showNotification();
this.notifier.notify();
return t;
}
getNextUrl(contractTerms: ContractTerms): string {
const fu = new URI(contractTerms.fulfillment_url);
fu.addSearch("order_id", contractTerms.order_id);
return fu.href();
}
/**
* Check if a payment for the given taler://pay/ URI is possible.
*
* If the payment is possible, the signature are already generated but not
* yet send to the merchant.
*/
async preparePay(talerPayUri: string): Promise {
const uriResult = parsePayUri(talerPayUri);
if (!uriResult) {
return {
status: "error",
error: "URI not supported",
};
}
let proposalId: string;
try {
proposalId = await this.downloadProposal(
uriResult.downloadUrl,
uriResult.sessionId,
);
} catch (e) {
return {
status: "error",
error: e.toString(),
};
}
const proposal = await this.getProposal(proposalId);
if (!proposal) {
throw Error(`could not get proposal ${proposalId}`);
}
console.log("proposal", proposal);
const differentPurchase = await oneShotGetIndexed(
this.db,
Stores.purchases.fulfillmentUrlIndex,
proposal.contractTerms.fulfillment_url,
);
let fulfillmentUrl = proposal.contractTerms.fulfillment_url;
let doublePurchaseDetection = false;
if (fulfillmentUrl.startsWith("http")) {
doublePurchaseDetection = true;
}
if (differentPurchase && doublePurchaseDetection) {
// We do this check to prevent merchant B to find out if we bought a
// digital product with merchant A by abusing the existing payment
// redirect feature.
if (
differentPurchase.contractTerms.merchant_pub !=
proposal.contractTerms.merchant_pub
) {
console.warn(
"merchant with different public key offered contract with same fulfillment URL as an existing purchase",
);
} else {
if (uriResult.sessionId) {
await this.submitPay(
differentPurchase.contractTermsHash,
uriResult.sessionId,
);
}
return {
status: "paid",
contractTerms: differentPurchase.contractTerms,
nextUrl: this.getNextUrl(differentPurchase.contractTerms),
};
}
}
// First check if we already payed for it.
const purchase = await oneShotGet(
this.db,
Stores.purchases,
proposal.contractTermsHash,
);
if (!purchase) {
const paymentAmount = Amounts.parseOrThrow(proposal.contractTerms.amount);
let wireFeeLimit;
if (proposal.contractTerms.max_wire_fee) {
wireFeeLimit = Amounts.parseOrThrow(
proposal.contractTerms.max_wire_fee,
);
} else {
wireFeeLimit = Amounts.getZero(paymentAmount.currency);
}
// If not already payed, check if we could pay for it.
const res = await this.getCoinsForPayment({
allowedAuditors: proposal.contractTerms.auditors,
allowedExchanges: proposal.contractTerms.exchanges,
depositFeeLimit: Amounts.parseOrThrow(proposal.contractTerms.max_fee),
paymentAmount,
wireFeeAmortization: proposal.contractTerms.wire_fee_amortization || 1,
wireFeeLimit,
// FIXME: parse this properly
wireFeeTime: extractTalerStamp(proposal.contractTerms.timestamp) || {
t_ms: 0,
},
wireMethod: proposal.contractTerms.wire_method,
});
if (!res) {
console.log("not confirming payment, insufficient coins");
return {
status: "insufficient-balance",
contractTerms: proposal.contractTerms,
proposalId: proposal.proposalId,
};
}
// Only create speculative signature if we don't already have one for this proposal
if (
!this.speculativePayData ||
(this.speculativePayData &&
this.speculativePayData.orderDownloadId !== proposalId)
) {
const { exchangeUrl, cds, totalAmount } = res;
const payCoinInfo = await this.cryptoApi.signDeposit(
proposal.contractTerms,
cds,
totalAmount,
);
this.speculativePayData = {
exchangeUrl,
payCoinInfo,
proposal,
orderDownloadId: proposalId,
};
Wallet.enableTracing &&
console.log("created speculative pay data for payment");
}
return {
status: "payment-possible",
contractTerms: proposal.contractTerms,
proposalId: proposal.proposalId,
totalFees: res.totalFees,
};
}
if (uriResult.sessionId) {
await this.submitPay(purchase.contractTermsHash, uriResult.sessionId);
}
return {
status: "paid",
contractTerms: proposal.contractTerms,
nextUrl: this.getNextUrl(purchase.contractTerms),
};
}
/**
* Download a proposal and store it in the database.
* Returns an id for it to retrieve it later.
*
* @param sessionId Current session ID, if the proposal is being
* downloaded in the context of a session ID.
*/
async downloadProposal(url: string, sessionId?: string): Promise {
const oldProposal = await oneShotGetIndexed(
this.db,
Stores.proposals.urlIndex,
url,
);
if (oldProposal) {
return oldProposal.proposalId;
}
const { priv, pub } = await this.cryptoApi.createEddsaKeypair();
const parsed_url = new URI(url);
const urlWithNonce = parsed_url.setQuery({ nonce: pub }).href();
console.log("downloading contract from '" + urlWithNonce + "'");
let resp;
try {
resp = await this.http.get(urlWithNonce);
} catch (e) {
console.log("contract download failed", e);
throw e;
}
const proposal = Proposal.checked(resp.responseJson);
const contractTermsHash = await this.hashContract(proposal.contract_terms);
const proposalId = encodeCrock(getRandomBytes(32));
const proposalRecord: ProposalRecord = {
contractTerms: proposal.contract_terms,
contractTermsHash,
merchantSig: proposal.sig,
noncePriv: priv,
timestamp: getTimestampNow(),
url,
downloadSessionId: sessionId,
proposalId: proposalId,
proposalStatus: ProposalStatus.PROPOSED,
};
await oneShotPut(this.db, Stores.proposals, proposalRecord);
this.notifier.notify();
return proposalId;
}
async refundFailedPay(proposalId: number) {
console.log(`refunding failed payment with proposal id ${proposalId}`);
const proposal = await oneShotGet(this.db, Stores.proposals, proposalId);
if (!proposal) {
throw Error(`proposal with id ${proposalId} not found`);
}
const purchase = await oneShotGet(
this.db,
Stores.purchases,
proposal.contractTermsHash,
);
if (!purchase) {
throw Error("purchase not found for proposal");
}
if (purchase.finished) {
throw Error("can't auto-refund finished purchase");
}
}
async submitPay(
contractTermsHash: string,
sessionId: string | undefined,
): Promise {
const purchase = await oneShotGet(
this.db,
Stores.purchases,
contractTermsHash,
);
if (!purchase) {
throw Error("Purchase not found: " + contractTermsHash);
}
if (purchase.abortRequested) {
throw Error("not submitting payment for aborted purchase");
}
let resp;
const payReq = { ...purchase.payReq, session_id: sessionId };
const payUrl = new URI("pay")
.absoluteTo(purchase.contractTerms.merchant_base_url)
.href();
try {
resp = await this.http.postJson(payUrl, payReq);
} catch (e) {
// Gives the user the option to retry / abort and refresh
console.log("payment failed", e);
throw e;
}
const merchantResp = resp.responseJson;
console.log("got success from pay URL");
const merchantPub = purchase.contractTerms.merchant_pub;
const valid: boolean = await this.cryptoApi.isValidPaymentSignature(
merchantResp.sig,
contractTermsHash,
merchantPub,
);
if (!valid) {
console.error("merchant payment signature invalid");
// FIXME: properly display error
throw Error("merchant payment signature invalid");
}
purchase.finished = true;
const modifiedCoins: CoinRecord[] = [];
for (const pc of purchase.payReq.coins) {
const c = await oneShotGet(this.db, Stores.coins, pc.coin_pub);
if (!c) {
console.error("coin not found");
throw Error("coin used in payment not found");
}
c.status = CoinStatus.Dirty;
modifiedCoins.push(c);
}
await runWithWriteTransaction(
this.db,
[Stores.coins, Stores.purchases],
async tx => {
for (let c of modifiedCoins) {
tx.put(Stores.coins, c);
}
tx.put(Stores.purchases, purchase);
},
);
for (const c of purchase.payReq.coins) {
this.refresh(c.coin_pub);
}
const nextUrl = this.getNextUrl(purchase.contractTerms);
this.cachedNextUrl[purchase.contractTerms.fulfillment_url] = {
nextUrl,
lastSessionId: sessionId,
};
return { nextUrl };
}
/**
* Refresh all dirty coins.
* The returned promise resolves only after all refresh
* operations have completed.
*/
async refreshDirtyCoins(): Promise<{ numRefreshed: number }> {
let n = 0;
const coins = await oneShotIter(this.db, Stores.coins).toArray();
for (let coin of coins) {
if (coin.status == CoinStatus.Dirty) {
try {
await this.refresh(coin.coinPub);
} catch (e) {
console.log("error during refresh");
}
n += 1;
}
}
return { numRefreshed: n };
}
/**
* Add a contract to the wallet and sign coins, and send them.
*/
async confirmPay(
proposalId: string,
sessionIdOverride: string | undefined,
): Promise {
Wallet.enableTracing &&
console.log(
`executing confirmPay with proposalId ${proposalId} and sessionIdOverride ${sessionIdOverride}`,
);
const proposal = await oneShotGet(this.db, Stores.proposals, proposalId);
if (!proposal) {
throw Error(`proposal with id ${proposalId} not found`);
}
const sessionId = sessionIdOverride || proposal.downloadSessionId;
let purchase = await oneShotGet(
this.db,
Stores.purchases,
proposal.contractTermsHash,
);
if (purchase) {
return this.submitPay(purchase.contractTermsHash, sessionId);
}
const contractAmount = Amounts.parseOrThrow(proposal.contractTerms.amount);
let wireFeeLimit;
if (!proposal.contractTerms.max_wire_fee) {
wireFeeLimit = Amounts.getZero(contractAmount.currency);
} else {
wireFeeLimit = Amounts.parseOrThrow(proposal.contractTerms.max_wire_fee);
}
const res = await this.getCoinsForPayment({
allowedAuditors: proposal.contractTerms.auditors,
allowedExchanges: proposal.contractTerms.exchanges,
depositFeeLimit: Amounts.parseOrThrow(proposal.contractTerms.max_fee),
paymentAmount: Amounts.parseOrThrow(proposal.contractTerms.amount),
wireFeeAmortization: proposal.contractTerms.wire_fee_amortization || 1,
wireFeeLimit,
// FIXME: parse this properly
wireFeeTime: extractTalerStamp(proposal.contractTerms.timestamp) || {
t_ms: 0,
},
wireMethod: proposal.contractTerms.wire_method,
});
Wallet.enableTracing && console.log("coin selection result", res);
if (!res) {
// Should not happen, since checkPay should be called first
console.log("not confirming payment, insufficient coins");
throw Error("insufficient balance");
}
const sd = await this.getSpeculativePayData(proposalId);
if (!sd) {
const { exchangeUrl, cds, totalAmount } = res;
const payCoinInfo = await this.cryptoApi.signDeposit(
proposal.contractTerms,
cds,
totalAmount,
);
purchase = await this.recordConfirmPay(
proposal,
payCoinInfo,
exchangeUrl,
);
} else {
purchase = await this.recordConfirmPay(
sd.proposal,
sd.payCoinInfo,
sd.exchangeUrl,
);
}
return this.submitPay(purchase.contractTermsHash, sessionId);
}
/**
* Get the speculative pay data, but only if coins have not changed in between.
*/
async getSpeculativePayData(
proposalId: string,
): Promise {
const sp = this.speculativePayData;
if (!sp) {
return;
}
if (sp.orderDownloadId !== proposalId) {
return;
}
const coinKeys = sp.payCoinInfo.updatedCoins.map(x => x.coinPub);
const coins: CoinRecord[] = [];
for (let coinKey of coinKeys) {
const cc = await oneShotGet(this.db, Stores.coins, coinKey);
if (cc) {
coins.push(cc);
}
}
for (let i = 0; i < coins.length; i++) {
const specCoin = sp.payCoinInfo.originalCoins[i];
const currentCoin = coins[i];
// Coin does not exist anymore!
if (!currentCoin) {
return;
}
if (
Amounts.cmp(specCoin.currentAmount, currentCoin.currentAmount) !== 0
) {
return;
}
}
return sp;
}
private async processReserveBankStatus(reservePub: string): Promise {
let reserve = await oneShotGet(this.db, Stores.reserves, reservePub);
switch (reserve?.reserveStatus) {
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
case ReserveRecordStatus.REGISTERING_BANK:
break;
default:
return;
}
const bankStatusUrl = reserve.bankWithdrawStatusUrl;
if (!bankStatusUrl) {
return;
}
let status: WithdrawOperationStatusResponse;
try {
const statusResp = await this.http.get(bankStatusUrl);
status = WithdrawOperationStatusResponse.checked(statusResp.responseJson);
} catch (e) {
throw e;
}
if (status.selection_done) {
if (reserve.reserveStatus === ReserveRecordStatus.REGISTERING_BANK) {
await this.registerReserveWithBank(reservePub);
return await this.processReserveBankStatus(reservePub);
}
} else {
await this.registerReserveWithBank(reservePub);
return await this.processReserveBankStatus(reservePub);
}
if (status.transfer_done) {
await oneShotMutate(this.db, Stores.reserves, reservePub, r => {
switch (r.reserveStatus) {
case ReserveRecordStatus.REGISTERING_BANK:
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
break;
default:
return;
}
const now = getTimestampNow();
r.timestampConfirmed = now;
r.reserveStatus = ReserveRecordStatus.QUERYING_STATUS;
return r;
});
await this.processReserveImpl(reservePub);
} else {
await oneShotMutate(this.db, Stores.reserves, reservePub, r => {
switch (r.reserveStatus) {
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
break;
default:
return;
}
r.bankWithdrawConfirmUrl = status.confirm_transfer_url;
return r;
});
}
}
async registerReserveWithBank(reservePub: string) {
let reserve = await oneShotGet(this.db, Stores.reserves, reservePub);
switch (reserve?.reserveStatus) {
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
case ReserveRecordStatus.REGISTERING_BANK:
break;
default:
return;
}
const bankStatusUrl = reserve.bankWithdrawStatusUrl;
if (!bankStatusUrl) {
return;
}
console.log("making selection");
if (reserve.timestampReserveInfoPosted) {
throw Error("bank claims that reserve info selection is not done");
}
const bankResp = await this.http.postJson(bankStatusUrl, {
reserve_pub: reservePub,
selected_exchange: reserve.exchangeWire,
});
console.log("got response", bankResp);
await oneShotMutate(this.db, Stores.reserves, reservePub, r => {
switch (r.reserveStatus) {
case ReserveRecordStatus.REGISTERING_BANK:
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
break;
default:
return;
}
r.timestampReserveInfoPosted = getTimestampNow();
r.reserveStatus = ReserveRecordStatus.WAIT_CONFIRM_BANK;
return r;
});
return this.processReserveBankStatus(reservePub);
}
/**
* First fetch information requred to withdraw from the reserve,
* then deplete the reserve, withdrawing coins until it is empty.
*
* The returned promise resolves once the reserve is set to the
* state DORMANT.
*/
async processReserve(reservePub: string): Promise {
const p = this.memoProcessReserve.find(reservePub);
if (p) {
return p;
} else {
return this.memoProcessReserve.put(
reservePub,
this.processReserveImpl(reservePub),
);
}
}
private async processReserveImpl(reservePub: string): Promise {
const reserve = await oneShotGet(this.db, Stores.reserves, reservePub);
if (!reserve) {
console.log("not processing reserve: reserve does not exist");
return;
}
logger.trace(
`Processing reserve ${reservePub} with status ${reserve.reserveStatus}`,
);
switch (reserve.reserveStatus) {
case ReserveRecordStatus.UNCONFIRMED:
// nothing to do
break;
case ReserveRecordStatus.REGISTERING_BANK:
await this.processReserveBankStatus(reservePub);
return this.processReserveImpl(reservePub);
case ReserveRecordStatus.QUERYING_STATUS:
await this.updateReserve(reservePub);
return this.processReserveImpl(reservePub);
case ReserveRecordStatus.WITHDRAWING:
await this.depleteReserve(reservePub);
break;
case ReserveRecordStatus.DORMANT:
// nothing to do
break;
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
await this.processReserveBankStatus(reservePub);
break;
default:
console.warn("unknown reserve record status:", reserve.reserveStatus);
assertUnreachable(reserve.reserveStatus);
break;
}
}
/**
* Given a planchet, withdraw a coin from the exchange.
*/
private async processPlanchet(coinPub: string): Promise {
logger.trace("process planchet", coinPub);
const planchet = await oneShotGet(this.db, Stores.planchets, coinPub);
if (!planchet) {
console.log("processPlanchet: planchet not found");
return;
}
const exchange = await oneShotGet(
this.db,
Stores.exchanges,
planchet.exchangeBaseUrl,
);
if (!exchange) {
console.error("db inconsistent: exchange for planchet not found");
return;
}
const denom = await oneShotGet(this.db, Stores.denominations, [
planchet.exchangeBaseUrl,
planchet.denomPub,
]);
if (!denom) {
console.error("db inconsistent: denom for planchet not found");
return;
}
const wd: any = {};
wd.denom_pub_hash = planchet.denomPubHash;
wd.reserve_pub = planchet.reservePub;
wd.reserve_sig = planchet.withdrawSig;
wd.coin_ev = planchet.coinEv;
const reqUrl = new URI("reserve/withdraw").absoluteTo(exchange.baseUrl);
const resp = await this.http.postJson(reqUrl.href(), wd);
const r = resp.responseJson;
const denomSig = await this.cryptoApi.rsaUnblind(
r.ev_sig,
planchet.blindingKey,
planchet.denomPub,
);
const coin: CoinRecord = {
blindingKey: planchet.blindingKey,
coinPriv: planchet.coinPriv,
coinPub: planchet.coinPub,
currentAmount: planchet.coinValue,
denomPub: planchet.denomPub,
denomPubHash: planchet.denomPubHash,
denomSig,
exchangeBaseUrl: planchet.exchangeBaseUrl,
reservePub: planchet.reservePub,
status: CoinStatus.Fresh,
coinIndex: planchet.coinIndex,
withdrawSessionId: planchet.withdrawSessionId,
};
await runWithWriteTransaction(
this.db,
[Stores.planchets, Stores.coins, Stores.withdrawalSession, Stores.reserves],
async tx => {
const currentPc = await tx.get(Stores.planchets, coin.coinPub);
if (!currentPc) {
return;
}
const ws = await tx.get(
Stores.withdrawalSession,
planchet.withdrawSessionId,
);
if (!ws) {
return;
}
if (ws.withdrawn[planchet.coinIndex]) {
// Already withdrawn
return;
}
ws.withdrawn[planchet.coinIndex] = true;
await tx.put(Stores.withdrawalSession, ws);
const r = await tx.get(Stores.reserves, planchet.reservePub);
if (!r) {
return;
}
r.withdrawCompletedAmount = Amounts.add(
r.withdrawCompletedAmount,
Amounts.add(denom.value, denom.feeWithdraw).amount,
).amount;
tx.put(Stores.reserves, r);
await tx.delete(Stores.planchets, coin.coinPub);
await tx.add(Stores.coins, coin);
},
);
this.notifier.notify();
logger.trace(`withdraw of one coin ${coin.coinPub} finished`);
}
/**
* Create a reserve, but do not flag it as confirmed yet.
*
* Adds the corresponding exchange as a trusted exchange if it is neither
* audited nor trusted already.
*/
async createReserve(
req: CreateReserveRequest,
): Promise {
const keypair = await this.cryptoApi.createEddsaKeypair();
const now = getTimestampNow();
const canonExchange = canonicalizeBaseUrl(req.exchange);
let reserveStatus;
if (req.bankWithdrawStatusUrl) {
reserveStatus = ReserveRecordStatus.REGISTERING_BANK;
} else {
reserveStatus = ReserveRecordStatus.UNCONFIRMED;
}
const currency = req.amount.currency;
const reserveRecord: ReserveRecord = {
created: now,
withdrawAllocatedAmount: Amounts.getZero(currency),
withdrawCompletedAmount: Amounts.getZero(currency),
withdrawRemainingAmount: Amounts.getZero(currency),
exchangeBaseUrl: canonExchange,
hasPayback: false,
initiallyRequestedAmount: req.amount,
reservePriv: keypair.priv,
reservePub: keypair.pub,
senderWire: req.senderWire,
timestampConfirmed: undefined,
timestampReserveInfoPosted: undefined,
bankWithdrawStatusUrl: req.bankWithdrawStatusUrl,
exchangeWire: req.exchangeWire,
reserveStatus,
lastStatusQuery: undefined,
};
const senderWire = req.senderWire;
if (senderWire) {
const rec = {
paytoUri: senderWire,
};
await oneShotPut(this.db, Stores.senderWires, rec);
}
const exchangeInfo = await this.updateExchangeFromUrl(req.exchange);
const exchangeDetails = exchangeInfo.details;
if (!exchangeDetails) {
throw Error("exchange not updated");
}
const { isAudited, isTrusted } = await this.getExchangeTrust(exchangeInfo);
let currencyRecord = await oneShotGet(
this.db,
Stores.currencies,
exchangeDetails.currency,
);
if (!currencyRecord) {
currencyRecord = {
auditors: [],
exchanges: [],
fractionalDigits: 2,
name: exchangeDetails.currency,
};
}
if (!isAudited && !isTrusted) {
currencyRecord.exchanges.push({
baseUrl: req.exchange,
exchangePub: exchangeDetails.masterPublicKey,
});
}
const cr: CurrencyRecord = currencyRecord;
const resp = await runWithWriteTransaction(
this.db,
[Stores.currencies, Stores.reserves, Stores.bankWithdrawUris],
async tx => {
// Check if we have already created a reserve for that bankWithdrawStatusUrl
if (reserveRecord.bankWithdrawStatusUrl) {
const bwi = await tx.get(
Stores.bankWithdrawUris,
reserveRecord.bankWithdrawStatusUrl,
);
if (bwi) {
const otherReserve = await tx.get(Stores.reserves, bwi.reservePub);
if (otherReserve) {
logger.trace(
"returning existing reserve for bankWithdrawStatusUri",
);
return {
exchange: otherReserve.exchangeBaseUrl,
reservePub: otherReserve.reservePub,
};
}
}
await tx.put(Stores.bankWithdrawUris, {
reservePub: reserveRecord.reservePub,
talerWithdrawUri: reserveRecord.bankWithdrawStatusUrl,
});
}
await tx.put(Stores.currencies, cr);
await tx.put(Stores.reserves, reserveRecord);
const r: CreateReserveResponse = {
exchange: canonExchange,
reservePub: keypair.pub,
};
return r;
},
);
// Asynchronously process the reserve, but return
// to the caller already.
this.processReserve(resp.reservePub).catch(e => {
console.error("Processing reserve failed:", e);
});
return resp;
}
/**
* Mark an existing reserve as confirmed. The wallet will start trying
* to withdraw from that reserve. This may not immediately succeed,
* since the exchange might not know about the reserve yet, even though the
* bank confirmed its creation.
*
* A confirmed reserve should be shown to the user in the UI, while
* an unconfirmed reserve should be hidden.
*/
async confirmReserve(req: ConfirmReserveRequest): Promise {
const now = getTimestampNow();
await oneShotMutate(this.db, Stores.reserves, req.reservePub, reserve => {
if (reserve.reserveStatus !== ReserveRecordStatus.UNCONFIRMED) {
return;
}
reserve.timestampConfirmed = now;
reserve.reserveStatus = ReserveRecordStatus.QUERYING_STATUS;
return reserve;
});
this.notifier.notify();
this.processReserve(req.reservePub).catch(e => {
console.log("processing reserve failed:", e);
});
}
/**
* Withdraw coins from a reserve until it is empty.
*
* When finished, marks the reserve as depleted by setting
* the depleted timestamp.
*/
private async depleteReserve(reservePub: string): Promise {
const reserve = await oneShotGet(this.db, Stores.reserves, reservePub);
if (!reserve) {
return;
}
if (reserve.reserveStatus !== ReserveRecordStatus.WITHDRAWING) {
return;
}
logger.trace(`depleting reserve ${reservePub}`);
const withdrawAmount = reserve.withdrawRemainingAmount;
logger.trace(`getting denom list`);
const denomsForWithdraw = await this.getVerifiedWithdrawDenomList(
reserve.exchangeBaseUrl,
withdrawAmount,
);
logger.trace(`got denom list`);
if (denomsForWithdraw.length === 0) {
const m = `Unable to withdraw from reserve, no denominations are available to withdraw.`;
await this.setReserveError(reserve.reservePub, {
type: "internal",
message: m,
details: {},
});
console.log(m);
throw new OperationFailedAndReportedError(m);
}
logger.trace("selected denominations");
const withdrawalSessionId = encodeCrock(randomBytes(32));
const withdrawalRecord: WithdrawalSessionRecord = {
withdrawSessionId: withdrawalSessionId,
reservePub: reserve.reservePub,
withdrawalAmount: Amounts.toString(withdrawAmount),
startTimestamp: getTimestampNow(),
denoms: denomsForWithdraw.map(x => x.denomPub),
withdrawn: denomsForWithdraw.map(x => false),
planchetCreated: denomsForWithdraw.map(x => false),
};
const totalCoinValue = Amounts.sum(denomsForWithdraw.map(x => x.value))
.amount;
const totalCoinWithdrawFee = Amounts.sum(
denomsForWithdraw.map(x => x.feeWithdraw),
).amount;
const totalWithdrawAmount = Amounts.add(
totalCoinValue,
totalCoinWithdrawFee,
).amount;
function mutateReserve(r: ReserveRecord): ReserveRecord {
const remaining = Amounts.sub(
r.withdrawRemainingAmount,
totalWithdrawAmount,
);
if (remaining.saturated) {
console.error("can't create planchets, saturated");
throw TransactionAbort;
}
const allocated = Amounts.add(
r.withdrawAllocatedAmount,
totalWithdrawAmount,
);
if (allocated.saturated) {
console.error("can't create planchets, saturated");
throw TransactionAbort;
}
r.withdrawRemainingAmount = remaining.amount;
r.withdrawAllocatedAmount = allocated.amount;
r.reserveStatus = ReserveRecordStatus.DORMANT;
return r;
}
const success = await runWithWriteTransaction(
this.db,
[Stores.planchets, Stores.withdrawalSession, Stores.reserves],
async tx => {
const myReserve = await tx.get(Stores.reserves, reservePub);
if (!myReserve) {
return false;
}
if (myReserve.reserveStatus !== ReserveRecordStatus.WITHDRAWING) {
return false;
}
await tx.mutate(Stores.reserves, reserve.reservePub, mutateReserve);
await tx.put(Stores.withdrawalSession, withdrawalRecord);
return true;
},
);
if (success) {
console.log("processing new withdraw session");
await this.processWithdrawSession(withdrawalSessionId);
} else {
console.trace("withdraw session already existed");
}
}
private async processWithdrawSession(withdrawalSessionId: string): Promise {
logger.trace("processing withdraw session", withdrawalSessionId);
const ws = await oneShotGet(
this.db,
Stores.withdrawalSession,
withdrawalSessionId,
);
if (!ws) {
logger.trace("withdraw session doesn't exist");
return;
}
const ps = ws.denoms.map((d, i) =>
this.processWithdrawCoin(withdrawalSessionId, i),
);
await Promise.all(ps);
this.badge.showNotification();
return;
}
private async processWithdrawCoin(
withdrawalSessionId: string,
coinIndex: number,
) {
logger.info("starting withdraw for coin");
const ws = await oneShotGet(
this.db,
Stores.withdrawalSession,
withdrawalSessionId,
);
if (!ws) {
console.log("ws doesn't exist");
return;
}
const coin = await oneShotGetIndexed(
this.db,
Stores.coins.byWithdrawalWithIdx,
[withdrawalSessionId, coinIndex],
);
if (coin) {
console.log("coin already exists");
return;
}
const pc = await oneShotGetIndexed(
this.db,
Stores.planchets.byWithdrawalWithIdx,
[withdrawalSessionId, coinIndex],
);
if (pc) {
return this.processPlanchet(pc.coinPub);
} else {
const reserve = await oneShotGet(this.db, Stores.reserves, ws.reservePub);
if (!reserve) {
return;
}
const denom = await oneShotGet(this.db, Stores.denominations, [
reserve.exchangeBaseUrl,
ws.denoms[coinIndex],
]);
if (!denom) {
return;
}
const r = await this.cryptoApi.createPlanchet(denom, reserve);
const newPlanchet: PlanchetRecord = {
blindingKey: r.blindingKey,
coinEv: r.coinEv,
coinIndex,
coinPriv: r.coinPriv,
coinPub: r.coinPub,
coinValue: r.coinValue,
denomPub: r.denomPub,
denomPubHash: r.denomPubHash,
exchangeBaseUrl: r.exchangeBaseUrl,
isFromTip: false,
reservePub: r.reservePub,
withdrawSessionId: withdrawalSessionId,
withdrawSig: r.withdrawSig,
};
await runWithWriteTransaction(this.db, [Stores.planchets, Stores.withdrawalSession], async (tx) => {
const myWs = await tx.get(Stores.withdrawalSession, withdrawalSessionId);
if (!myWs) {
return;
}
if (myWs.planchetCreated[coinIndex]) {
return;
}
await tx.put(Stores.planchets, newPlanchet);
});
await this.processPlanchet(newPlanchet.coinPub);
}
}
/**
* Update the information about a reserve that is stored in the wallet
* by quering the reserve's exchange.
*/
private async updateReserve(reservePub: string): Promise {
const reserve = await oneShotGet(this.db, Stores.reserves, reservePub);
if (!reserve) {
throw Error("reserve not in db");
}
if (reserve.timestampConfirmed === undefined) {
throw Error("reserve not confirmed yet");
}
if (reserve.reserveStatus !== ReserveRecordStatus.QUERYING_STATUS) {
return;
}
const reqUrl = new URI("reserve/status").absoluteTo(
reserve.exchangeBaseUrl,
);
reqUrl.query({ reserve_pub: reservePub });
let resp;
try {
resp = await this.http.get(reqUrl.href());
} catch (e) {
if (e.response?.status === 404) {
return;
} else {
const m = e.message;
this.setReserveError(reservePub, {
type: "network",
details: {},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
}
const reserveInfo = ReserveStatus.checked(resp.responseJson);
const balance = Amounts.parseOrThrow(reserveInfo.balance);
await oneShotMutate(this.db, Stores.reserves, reserve.reservePub, r => {
if (r.reserveStatus !== ReserveRecordStatus.QUERYING_STATUS) {
return;
}
// FIXME: check / compare history!
if (!r.lastStatusQuery) {
// FIXME: check if this matches initial expectations
r.withdrawRemainingAmount = balance;
} else {
const expectedBalance = Amounts.sub(
r.withdrawAllocatedAmount,
r.withdrawCompletedAmount,
);
const cmp = Amounts.cmp(balance, expectedBalance.amount);
if (cmp == 0) {
// Nothing changed.
return;
}
if (cmp > 0) {
const extra = Amounts.sub(balance, expectedBalance.amount).amount;
r.withdrawRemainingAmount = Amounts.add(
r.withdrawRemainingAmount,
extra,
).amount;
} else {
// We're missing some money.
}
}
r.lastStatusQuery = getTimestampNow();
r.reserveStatus = ReserveRecordStatus.WITHDRAWING;
return r;
});
this.notifier.notify();
}
async getPossibleDenoms(
exchangeBaseUrl: string,
): Promise {
return await oneShotIterIndex(
this.db,
Stores.denominations.exchangeBaseUrlIndex,
exchangeBaseUrl,
).filter(d => {
return (
d.status === DenominationStatus.Unverified ||
d.status === DenominationStatus.VerifiedGood
);
});
}
/**
* Compute the smallest withdrawable amount possible, based on verified denominations.
*
* Writes to the DB in order to record the result from verifying
* denominations.
*/
async getVerifiedSmallestWithdrawAmount(
exchangeBaseUrl: string,
): Promise {
const exchange = await oneShotGet(
this.db,
Stores.exchanges,
exchangeBaseUrl,
);
if (!exchange) {
throw Error(`exchange ${exchangeBaseUrl} not found`);
}
const exchangeDetails = exchange.details;
if (!exchangeDetails) {
throw Error(`exchange ${exchangeBaseUrl} details not available`);
}
const possibleDenoms = await this.getPossibleDenoms(exchange.baseUrl);
possibleDenoms.sort((d1, d2) => {
const a1 = Amounts.add(d1.feeWithdraw, d1.value).amount;
const a2 = Amounts.add(d2.feeWithdraw, d2.value).amount;
return Amounts.cmp(a1, a2);
});
for (const denom of possibleDenoms) {
if (denom.status === DenominationStatus.VerifiedGood) {
return Amounts.add(denom.feeWithdraw, denom.value).amount;
}
const valid = await this.cryptoApi.isValidDenom(
denom,
exchangeDetails.masterPublicKey,
);
if (!valid) {
denom.status = DenominationStatus.VerifiedBad;
} else {
denom.status = DenominationStatus.VerifiedGood;
}
await oneShotPut(this.db, Stores.denominations, denom);
if (valid) {
return Amounts.add(denom.feeWithdraw, denom.value).amount;
}
}
return Amounts.getZero(exchangeDetails.currency);
}
/**
* Get a list of denominations to withdraw from the given exchange for the
* given amount, making sure that all denominations' signatures are verified.
*
* Writes to the DB in order to record the result from verifying
* denominations.
*/
async getVerifiedWithdrawDenomList(
exchangeBaseUrl: string,
amount: AmountJson,
): Promise {
const exchange = await oneShotGet(
this.db,
Stores.exchanges,
exchangeBaseUrl,
);
if (!exchange) {
console.log("exchange not found");
throw Error(`exchange ${exchangeBaseUrl} not found`);
}
const exchangeDetails = exchange.details;
if (!exchangeDetails) {
console.log("exchange details not available");
throw Error(`exchange ${exchangeBaseUrl} details not available`);
}
console.log("getting possible denoms");
const possibleDenoms = await this.getPossibleDenoms(exchange.baseUrl);
console.log("got possible denoms");
let allValid = false;
let selectedDenoms: DenominationRecord[];
do {
allValid = true;
const nextPossibleDenoms = [];
selectedDenoms = getWithdrawDenomList(amount, possibleDenoms);
console.log("got withdraw denom list");
for (const denom of selectedDenoms || []) {
if (denom.status === DenominationStatus.Unverified) {
console.log("checking validity", denom, exchangeDetails.masterPublicKey);
const valid = await this.cryptoApi.isValidDenom(
denom,
exchangeDetails.masterPublicKey,
);
console.log("done checking validity");
if (!valid) {
denom.status = DenominationStatus.VerifiedBad;
allValid = false;
} else {
denom.status = DenominationStatus.VerifiedGood;
nextPossibleDenoms.push(denom);
}
await oneShotPut(this.db, Stores.denominations, denom);
} else {
nextPossibleDenoms.push(denom);
}
}
} while (selectedDenoms.length > 0 && !allValid);
console.log("returning denoms");
return selectedDenoms;
}
/**
* Check if and how an exchange is trusted and/or audited.
*/
async getExchangeTrust(
exchangeInfo: ExchangeRecord,
): Promise<{ isTrusted: boolean; isAudited: boolean }> {
let isTrusted = false;
let isAudited = false;
const exchangeDetails = exchangeInfo.details;
if (!exchangeDetails) {
throw Error(`exchange ${exchangeInfo.baseUrl} details not available`);
}
const currencyRecord = await oneShotGet(
this.db,
Stores.currencies,
exchangeDetails.currency,
);
if (currencyRecord) {
for (const trustedExchange of currencyRecord.exchanges) {
if (trustedExchange.exchangePub === exchangeDetails.masterPublicKey) {
isTrusted = true;
break;
}
}
for (const trustedAuditor of currencyRecord.auditors) {
for (const exchangeAuditor of exchangeDetails.auditors) {
if (trustedAuditor.auditorPub === exchangeAuditor.auditor_pub) {
isAudited = true;
break;
}
}
}
}
return { isTrusted, isAudited };
}
async getWithdrawDetailsForUri(
talerWithdrawUri: string,
maybeSelectedExchange?: string,
): Promise {
const info = await this.getWithdrawalInfo(talerWithdrawUri);
let rci: ReserveCreationInfo | undefined = undefined;
if (maybeSelectedExchange) {
rci = await this.getWithdrawDetailsForAmount(
maybeSelectedExchange,
info.amount,
);
}
return {
withdrawInfo: info,
reserveCreationInfo: rci,
};
}
async getWithdrawDetailsForAmount(
baseUrl: string,
amount: AmountJson,
): Promise {
const exchangeInfo = await this.updateExchangeFromUrl(baseUrl);
const exchangeDetails = exchangeInfo.details;
if (!exchangeDetails) {
throw Error(`exchange ${exchangeInfo.baseUrl} details not available`);
}
const exchangeWireInfo = exchangeInfo.wireInfo;
if (!exchangeWireInfo) {
throw Error(
`exchange ${exchangeInfo.baseUrl} wire details not available`,
);
}
const selectedDenoms = await this.getVerifiedWithdrawDenomList(
baseUrl,
amount,
);
let acc = Amounts.getZero(amount.currency);
for (const d of selectedDenoms) {
acc = Amounts.add(acc, d.feeWithdraw).amount;
}
const actualCoinCost = selectedDenoms
.map(
(d: DenominationRecord) => Amounts.add(d.value, d.feeWithdraw).amount,
)
.reduce((a, b) => Amounts.add(a, b).amount);
const exchangeWireAccounts: string[] = [];
for (let account of exchangeWireInfo.accounts) {
exchangeWireAccounts.push(account.url);
}
const { isTrusted, isAudited } = await this.getExchangeTrust(exchangeInfo);
let earliestDepositExpiration = selectedDenoms[0].stampExpireDeposit;
for (let i = 1; i < selectedDenoms.length; i++) {
const expireDeposit = selectedDenoms[i].stampExpireDeposit;
if (expireDeposit.t_ms < earliestDepositExpiration.t_ms) {
earliestDepositExpiration = expireDeposit;
}
}
const possibleDenoms = await oneShotIterIndex(
this.db,
Stores.denominations.exchangeBaseUrlIndex,
baseUrl,
).filter(d => d.isOffered);
const trustedAuditorPubs = [];
const currencyRecord = await oneShotGet(
this.db,
Stores.currencies,
amount.currency,
);
if (currencyRecord) {
trustedAuditorPubs.push(
...currencyRecord.auditors.map(a => a.auditorPub),
);
}
let versionMatch;
if (exchangeDetails.protocolVersion) {
versionMatch = LibtoolVersion.compare(
WALLET_PROTOCOL_VERSION,
exchangeDetails.protocolVersion,
);
if (
versionMatch &&
!versionMatch.compatible &&
versionMatch.currentCmp === -1
) {
console.warn(
`wallet version ${WALLET_PROTOCOL_VERSION} might be outdated ` +
`(exchange has ${exchangeDetails.protocolVersion}), checking for updates`,
);
if (isFirefox()) {
console.log("skipping update check on Firefox");
} else {
chrome.runtime.requestUpdateCheck((status, details) => {
console.log("update check status:", status);
});
}
}
}
const ret: ReserveCreationInfo = {
earliestDepositExpiration,
exchangeInfo,
exchangeWireAccounts,
exchangeVersion: exchangeDetails.protocolVersion || "unknown",
isAudited,
isTrusted,
numOfferedDenoms: possibleDenoms.length,
overhead: Amounts.sub(amount, actualCoinCost).amount,
selectedDenoms,
trustedAuditorPubs,
versionMatch,
walletVersion: WALLET_PROTOCOL_VERSION,
wireFees: exchangeWireInfo,
withdrawFee: acc,
};
return ret;
}
async getExchangePaytoUri(
exchangeBaseUrl: string,
supportedTargetTypes: string[],
): Promise {
// We do the update here, since the exchange might not even exist
// yet in our database.
const exchangeRecord = await this.updateExchangeFromUrl(exchangeBaseUrl);
if (!exchangeRecord) {
throw Error(`Exchange '${exchangeBaseUrl}' not found.`);
}
const exchangeWireInfo = exchangeRecord.wireInfo;
if (!exchangeWireInfo) {
throw Error(`Exchange wire info for '${exchangeBaseUrl}' not found.`);
}
for (let account of exchangeWireInfo.accounts) {
const paytoUri = new URI(account.url);
if (supportedTargetTypes.includes(paytoUri.authority())) {
return account.url;
}
}
throw Error("no matching exchange account found");
}
/**
* Update or add exchange DB entry by fetching the /keys and /wire information.
* Optionally link the reserve entry to the new or existing
* exchange entry in then DB.
*/
async updateExchangeFromUrl(
baseUrl: string,
force: boolean = false,
): Promise {
const now = getTimestampNow();
baseUrl = canonicalizeBaseUrl(baseUrl);
const r = await oneShotGet(this.db, Stores.exchanges, baseUrl);
if (!r) {
const newExchangeRecord: ExchangeRecord = {
baseUrl: baseUrl,
details: undefined,
wireInfo: undefined,
updateStatus: ExchangeUpdateStatus.FETCH_KEYS,
updateStarted: now,
updateReason: "initial",
timestampAdded: getTimestampNow(),
};
await oneShotPut(this.db, Stores.exchanges, newExchangeRecord);
} else {
await runWithWriteTransaction(this.db, [Stores.exchanges], async t => {
const rec = await t.get(Stores.exchanges, baseUrl);
if (!rec) {
return;
}
if (rec.updateStatus != ExchangeUpdateStatus.FETCH_KEYS && !force) {
return;
}
if (rec.updateStatus != ExchangeUpdateStatus.FETCH_KEYS && force) {
rec.updateReason = "forced";
}
rec.updateStarted = now;
rec.updateStatus = ExchangeUpdateStatus.FETCH_KEYS;
rec.lastError = undefined;
t.put(Stores.exchanges, rec);
});
}
await this.updateExchangeWithKeys(baseUrl);
await this.updateExchangeWithWireInfo(baseUrl);
const updatedExchange = await oneShotGet(
this.db,
Stores.exchanges,
baseUrl,
);
if (!updatedExchange) {
// This should practically never happen
throw Error("exchange not found");
}
return updatedExchange;
}
private async setExchangeError(
baseUrl: string,
err: OperationError,
): Promise {
const mut = (exchange: ExchangeRecord) => {
exchange.lastError = err;
return exchange;
};
await oneShotMutate(this.db, Stores.exchanges, baseUrl, mut);
}
private async setReserveError(
reservePub: string,
err: OperationError,
): Promise {
const mut = (reserve: ReserveRecord) => {
reserve.lastError = err;
return reserve;
};
await oneShotMutate(this.db, Stores.reserves, reservePub, mut);
}
/**
* Fetch the exchange's /keys and update our database accordingly.
*
* Exceptions thrown in this method must be caught and reported
* in the pending operations.
*/
private async updateExchangeWithKeys(baseUrl: string): Promise {
const existingExchangeRecord = await oneShotGet(
this.db,
Stores.exchanges,
baseUrl,
);
if (
existingExchangeRecord?.updateStatus != ExchangeUpdateStatus.FETCH_KEYS
) {
return;
}
const keysUrl = new URI("keys")
.absoluteTo(baseUrl)
.addQuery("cacheBreaker", WALLET_CACHE_BREAKER_CLIENT_VERSION);
let keysResp;
try {
keysResp = await this.http.get(keysUrl.href());
} catch (e) {
const m = `Fetching keys failed: ${e.message}`;
await this.setExchangeError(baseUrl, {
type: "network",
details: {
requestUrl: e.config?.url,
},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
let exchangeKeysJson: KeysJson;
try {
exchangeKeysJson = KeysJson.checked(keysResp.responseJson);
} catch (e) {
const m = `Parsing /keys response failed: ${e.message}`;
await this.setExchangeError(baseUrl, {
type: "protocol-violation",
details: {},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
const lastUpdateTimestamp = extractTalerStamp(
exchangeKeysJson.list_issue_date,
);
if (!lastUpdateTimestamp) {
const m = `Parsing /keys response failed: invalid list_issue_date.`;
await this.setExchangeError(baseUrl, {
type: "protocol-violation",
details: {},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
if (exchangeKeysJson.denoms.length === 0) {
const m = "exchange doesn't offer any denominations";
await this.setExchangeError(baseUrl, {
type: "protocol-violation",
details: {},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
const protocolVersion = exchangeKeysJson.version;
if (!protocolVersion) {
const m = "outdate exchange, no version in /keys response";
await this.setExchangeError(baseUrl, {
type: "protocol-violation",
details: {},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
const currency = Amounts.parseOrThrow(exchangeKeysJson.denoms[0].value)
.currency;
const newDenominations = await Promise.all(
exchangeKeysJson.denoms.map(d =>
this.denominationRecordFromKeys(baseUrl, d),
),
);
await runWithWriteTransaction(
this.db,
[Stores.exchanges, Stores.denominations],
async tx => {
const r = await tx.get(Stores.exchanges, baseUrl);
if (!r) {
console.warn(`exchange ${baseUrl} no longer present`);
return;
}
if (r.details) {
// FIXME: We need to do some consistency checks!
}
r.details = {
auditors: exchangeKeysJson.auditors,
currency: currency,
lastUpdateTime: lastUpdateTimestamp,
masterPublicKey: exchangeKeysJson.master_public_key,
protocolVersion: protocolVersion,
};
r.updateStatus = ExchangeUpdateStatus.FETCH_WIRE;
r.lastError = undefined;
await tx.put(Stores.exchanges, r);
for (const newDenom of newDenominations) {
const oldDenom = await tx.get(Stores.denominations, [
baseUrl,
newDenom.denomPub,
]);
if (oldDenom) {
// FIXME: Do consistency check
} else {
await tx.put(Stores.denominations, newDenom);
}
}
},
);
}
/**
* Fetch wire information for an exchange and store it in the database.
*
* @param exchangeBaseUrl Exchange base URL, assumed to be already normalized.
*/
private async updateExchangeWithWireInfo(exchangeBaseUrl: string) {
const exchange = await this.findExchange(exchangeBaseUrl);
if (!exchange) {
return;
}
if (exchange.updateStatus != ExchangeUpdateStatus.FETCH_WIRE) {
return;
}
const reqUrl = new URI("wire")
.absoluteTo(exchangeBaseUrl)
.addQuery("cacheBreaker", WALLET_CACHE_BREAKER_CLIENT_VERSION);
const resp = await this.http.get(reqUrl.href());
const wiJson = resp.responseJson;
if (!wiJson) {
throw Error("/wire response malformed");
}
const wireInfo = ExchangeWireJson.checked(wiJson);
const feesForType: { [wireMethod: string]: WireFee[] } = {};
for (const wireMethod of Object.keys(wireInfo.fees)) {
const feeList: WireFee[] = [];
for (const x of wireInfo.fees[wireMethod]) {
const startStamp = extractTalerStamp(x.start_date);
if (!startStamp) {
throw Error("wrong date format");
}
const endStamp = extractTalerStamp(x.end_date);
if (!endStamp) {
throw Error("wrong date format");
}
feeList.push({
closingFee: Amounts.parseOrThrow(x.closing_fee),
endStamp,
sig: x.sig,
startStamp,
wireFee: Amounts.parseOrThrow(x.wire_fee),
});
}
feesForType[wireMethod] = feeList;
}
await runWithWriteTransaction(this.db, [Stores.exchanges], async tx => {
const r = await tx.get(Stores.exchanges, exchangeBaseUrl);
if (!r) {
return;
}
if (r.updateStatus != ExchangeUpdateStatus.FETCH_WIRE) {
return;
}
r.wireInfo = {
accounts: wireInfo.accounts,
feesForType: feesForType,
};
r.updateStatus = ExchangeUpdateStatus.FINISHED;
r.lastError = undefined;
await tx.put(Stores.exchanges, r);
});
}
/**
* Get detailed balance information, sliced by exchange and by currency.
*/
async getBalances(): Promise {
/**
* Add amount to a balance field, both for
* the slicing by exchange and currency.
*/
function addTo(
balance: WalletBalance,
field: keyof WalletBalanceEntry,
amount: AmountJson,
exchange: string,
): void {
const z = Amounts.getZero(amount.currency);
const balanceIdentity = {
available: z,
paybackAmount: z,
pendingIncoming: z,
pendingPayment: z,
pendingIncomingDirty: z,
pendingIncomingRefresh: z,
pendingIncomingWithdraw: z,
};
let entryCurr = balance.byCurrency[amount.currency];
if (!entryCurr) {
balance.byCurrency[amount.currency] = entryCurr = {
...balanceIdentity,
};
}
let entryEx = balance.byExchange[exchange];
if (!entryEx) {
balance.byExchange[exchange] = entryEx = { ...balanceIdentity };
}
entryCurr[field] = Amounts.add(entryCurr[field], amount).amount;
entryEx[field] = Amounts.add(entryEx[field], amount).amount;
}
const balanceStore = {
byCurrency: {},
byExchange: {},
};
await runWithWriteTransaction(
this.db,
[Stores.coins, Stores.refresh, Stores.reserves, Stores.purchases],
async tx => {
await tx.iter(Stores.coins).forEach(c => {
if (c.suspended) {
return;
}
if (c.status === CoinStatus.Fresh) {
addTo(
balanceStore,
"available",
c.currentAmount,
c.exchangeBaseUrl,
);
}
if (c.status === CoinStatus.Dirty) {
addTo(
balanceStore,
"pendingIncoming",
c.currentAmount,
c.exchangeBaseUrl,
);
addTo(
balanceStore,
"pendingIncomingDirty",
c.currentAmount,
c.exchangeBaseUrl,
);
}
});
await tx.iter(Stores.refresh).forEach(r => {
// Don't count finished refreshes, since the refresh already resulted
// in coins being added to the wallet.
if (r.finished) {
return;
}
addTo(
balanceStore,
"pendingIncoming",
r.valueOutput,
r.exchangeBaseUrl,
);
addTo(
balanceStore,
"pendingIncomingRefresh",
r.valueOutput,
r.exchangeBaseUrl,
);
});
await tx.iter(Stores.purchases).forEach(t => {
if (t.finished) {
return;
}
for (const c of t.payReq.coins) {
addTo(
balanceStore,
"pendingPayment",
Amounts.parseOrThrow(c.contribution),
c.exchange_url,
);
}
});
},
);
Wallet.enableTracing && console.log("computed balances:", balanceStore);
return balanceStore;
}
async refresh(oldCoinPub: string, force: boolean = false): Promise {
const coin = await oneShotGet(this.db, Stores.coins, oldCoinPub);
if (!coin) {
console.warn("can't refresh, coin not in database");
return;
}
switch (coin.status) {
case CoinStatus.Dirty:
break;
case CoinStatus.Dormant:
return;
case CoinStatus.Fresh:
if (!force) {
return;
}
break;
}
const exchange = await this.updateExchangeFromUrl(coin.exchangeBaseUrl);
if (!exchange) {
throw Error("db inconsistent: exchange of coin not found");
}
const oldDenom = await oneShotGet(this.db, Stores.denominations, [
exchange.baseUrl,
coin.denomPub,
]);
if (!oldDenom) {
throw Error("db inconsistent: denomination for coin not found");
}
const availableDenoms: DenominationRecord[] = await oneShotIterIndex(
this.db,
Stores.denominations.exchangeBaseUrlIndex,
exchange.baseUrl,
).toArray();
const availableAmount = Amounts.sub(coin.currentAmount, oldDenom.feeRefresh)
.amount;
const newCoinDenoms = getWithdrawDenomList(
availableAmount,
availableDenoms,
);
if (newCoinDenoms.length === 0) {
logger.trace(
`not refreshing, available amount ${amountToPretty(
availableAmount,
)} too small`,
);
await oneShotMutate(this.db, Stores.coins, oldCoinPub, x => {
if (x.status != coin.status) {
// Concurrent modification?
return;
}
x.status = CoinStatus.Dormant;
return x;
});
this.notifier.notify();
return;
}
const refreshSession: RefreshSessionRecord = await this.cryptoApi.createRefreshSession(
exchange.baseUrl,
3,
coin,
newCoinDenoms,
oldDenom.feeRefresh,
);
function mutateCoin(c: CoinRecord): CoinRecord {
const r = Amounts.sub(c.currentAmount, refreshSession.valueWithFee);
if (r.saturated) {
// Something else must have written the coin value
throw TransactionAbort;
}
c.currentAmount = r.amount;
c.status = CoinStatus.Dormant;
return c;
}
// Store refresh session and subtract refreshed amount from
// coin in the same transaction.
await runWithWriteTransaction(
this.db,
[Stores.refresh, Stores.coins],
async tx => {
await tx.put(Stores.refresh, refreshSession);
await tx.mutate(Stores.coins, coin.coinPub, mutateCoin);
},
);
logger.info(`created refresh session ${refreshSession.refreshSessionId}`);
this.notifier.notify();
await this.processRefreshSession(refreshSession.refreshSessionId);
}
async processRefreshSession(refreshSessionId: string) {
const refreshSession = await oneShotGet(
this.db,
Stores.refresh,
refreshSessionId,
);
if (!refreshSession) {
return;
}
if (refreshSession.finished) {
return;
}
if (typeof refreshSession.norevealIndex !== "number") {
await this.refreshMelt(refreshSession.refreshSessionId);
}
await this.refreshReveal(refreshSession.refreshSessionId);
logger.trace("refresh finished");
}
async refreshMelt(refreshSessionId: string): Promise {
const refreshSession = await oneShotGet(
this.db,
Stores.refresh,
refreshSessionId,
);
if (!refreshSession) {
return;
}
if (refreshSession.norevealIndex !== undefined) {
return;
}
const coin = await oneShotGet(
this.db,
Stores.coins,
refreshSession.meltCoinPub,
);
if (!coin) {
console.error("can't melt coin, it does not exist");
return;
}
const reqUrl = new URI("refresh/melt").absoluteTo(
refreshSession.exchangeBaseUrl,
);
const meltReq = {
coin_pub: coin.coinPub,
confirm_sig: refreshSession.confirmSig,
denom_pub_hash: coin.denomPubHash,
denom_sig: coin.denomSig,
rc: refreshSession.hash,
value_with_fee: refreshSession.valueWithFee,
};
Wallet.enableTracing && console.log("melt request:", meltReq);
const resp = await this.http.postJson(reqUrl.href(), meltReq);
Wallet.enableTracing && console.log("melt response:", resp.responseJson);
if (resp.status !== 200) {
console.error(resp.responseJson);
throw Error("refresh failed");
}
const respJson = resp.responseJson;
const norevealIndex = respJson.noreveal_index;
if (typeof norevealIndex !== "number") {
throw Error("invalid response");
}
refreshSession.norevealIndex = norevealIndex;
await oneShotMutate(this.db, Stores.refresh, refreshSessionId, rs => {
if (rs.norevealIndex !== undefined) {
return;
}
if (rs.finished) {
return;
}
rs.norevealIndex = norevealIndex;
return rs;
});
this.notifier.notify();
}
private async refreshReveal(refreshSessionId: string): Promise {
const refreshSession = await oneShotGet(
this.db,
Stores.refresh,
refreshSessionId,
);
if (!refreshSession) {
return;
}
const norevealIndex = refreshSession.norevealIndex;
if (norevealIndex === undefined) {
throw Error("can't reveal without melting first");
}
const privs = Array.from(refreshSession.transferPrivs);
privs.splice(norevealIndex, 1);
const planchets = refreshSession.planchetsForGammas[norevealIndex];
if (!planchets) {
throw Error("refresh index error");
}
const meltCoinRecord = await oneShotGet(
this.db,
Stores.coins,
refreshSession.meltCoinPub,
);
if (!meltCoinRecord) {
throw Error("inconsistent database");
}
const evs = planchets.map((x: RefreshPlanchetRecord) => x.coinEv);
const linkSigs: string[] = [];
for (let i = 0; i < refreshSession.newDenoms.length; i++) {
const linkSig = await this.cryptoApi.signCoinLink(
meltCoinRecord.coinPriv,
refreshSession.newDenomHashes[i],
refreshSession.meltCoinPub,
refreshSession.transferPubs[norevealIndex],
planchets[i].coinEv,
);
linkSigs.push(linkSig);
}
const req = {
coin_evs: evs,
new_denoms_h: refreshSession.newDenomHashes,
rc: refreshSession.hash,
transfer_privs: privs,
transfer_pub: refreshSession.transferPubs[norevealIndex],
link_sigs: linkSigs,
};
const reqUrl = new URI("refresh/reveal").absoluteTo(
refreshSession.exchangeBaseUrl,
);
Wallet.enableTracing && console.log("reveal request:", req);
let resp;
try {
resp = await this.http.postJson(reqUrl.href(), req);
} catch (e) {
console.error("got error during /refresh/reveal request");
console.error(e);
return;
}
Wallet.enableTracing && console.log("session:", refreshSession);
Wallet.enableTracing && console.log("reveal response:", resp);
if (resp.status !== 200) {
console.error("error: /refresh/reveal returned status " + resp.status);
return;
}
const respJson = resp.responseJson;
if (!respJson.ev_sigs || !Array.isArray(respJson.ev_sigs)) {
console.error("/refresh/reveal did not contain ev_sigs");
return;
}
const exchange = await this.findExchange(refreshSession.exchangeBaseUrl);
if (!exchange) {
console.error(`exchange ${refreshSession.exchangeBaseUrl} not found`);
return;
}
const coins: CoinRecord[] = [];
for (let i = 0; i < respJson.ev_sigs.length; i++) {
const denom = await oneShotGet(this.db, Stores.denominations, [
refreshSession.exchangeBaseUrl,
refreshSession.newDenoms[i],
]);
if (!denom) {
console.error("denom not found");
continue;
}
const pc =
refreshSession.planchetsForGammas[refreshSession.norevealIndex!][i];
const denomSig = await this.cryptoApi.rsaUnblind(
respJson.ev_sigs[i].ev_sig,
pc.blindingKey,
denom.denomPub,
);
const coin: CoinRecord = {
blindingKey: pc.blindingKey,
coinPriv: pc.privateKey,
coinPub: pc.publicKey,
currentAmount: denom.value,
denomPub: denom.denomPub,
denomPubHash: denom.denomPubHash,
denomSig,
exchangeBaseUrl: refreshSession.exchangeBaseUrl,
reservePub: undefined,
status: CoinStatus.Fresh,
coinIndex: -1,
withdrawSessionId: "",
};
coins.push(coin);
}
refreshSession.finished = true;
await runWithWriteTransaction(
this.db,
[Stores.coins, Stores.refresh],
async tx => {
const rs = await tx.get(Stores.refresh, refreshSessionId);
if (!rs) {
return;
}
if (rs.finished) {
return;
}
for (let coin of coins) {
await tx.put(Stores.coins, coin);
}
await tx.put(Stores.refresh, refreshSession);
},
);
this.notifier.notify();
}
async findExchange(
exchangeBaseUrl: string,
): Promise {
return await oneShotGet(this.db, Stores.exchanges, exchangeBaseUrl);
}
/**
* Retrive the full event history for this wallet.
*/
async getHistory(
historyQuery?: HistoryQuery,
): Promise<{ history: HistoryEvent[] }> {
const history: HistoryEvent[] = [];
// FIXME: do pagination instead of generating the full history
// We uniquely identify history rows via their timestamp.
// This works as timestamps are guaranteed to be monotonically
// increasing even
const proposals = await oneShotIter(this.db, Stores.proposals).toArray();
for (const p of proposals) {
history.push({
detail: {
contractTermsHash: p.contractTermsHash,
merchantName: p.contractTerms.merchant.name,
},
timestamp: p.timestamp,
type: "claim-order",
explicit: false,
});
}
const withdrawals = await oneShotIter(
this.db,
Stores.withdrawalSession,
).toArray();
for (const w of withdrawals) {
history.push({
detail: {
withdrawalAmount: w.withdrawalAmount,
},
timestamp: w.startTimestamp,
type: "withdraw",
explicit: false,
});
}
const purchases = await oneShotIter(this.db, Stores.purchases).toArray();
for (const p of purchases) {
history.push({
detail: {
amount: p.contractTerms.amount,
contractTermsHash: p.contractTermsHash,
fulfillmentUrl: p.contractTerms.fulfillment_url,
merchantName: p.contractTerms.merchant.name,
},
timestamp: p.timestamp,
type: "pay",
explicit: false,
});
if (p.timestamp_refund) {
const contractAmount = Amounts.parseOrThrow(p.contractTerms.amount);
const amountsPending = Object.keys(p.refundsPending).map(x =>
Amounts.parseOrThrow(p.refundsPending[x].refund_amount),
);
const amountsDone = Object.keys(p.refundsDone).map(x =>
Amounts.parseOrThrow(p.refundsDone[x].refund_amount),
);
const amounts: AmountJson[] = amountsPending.concat(amountsDone);
const amount = Amounts.add(
Amounts.getZero(contractAmount.currency),
...amounts,
).amount;
history.push({
detail: {
contractTermsHash: p.contractTermsHash,
fulfillmentUrl: p.contractTerms.fulfillment_url,
merchantName: p.contractTerms.merchant.name,
refundAmount: amount,
},
timestamp: p.timestamp_refund,
type: "refund",
explicit: false,
});
}
}
const reserves = await oneShotIter(this.db, Stores.reserves).toArray();
for (const r of reserves) {
const reserveType = r.bankWithdrawStatusUrl ? "taler-bank" : "manual";
history.push({
detail: {
exchangeBaseUrl: r.exchangeBaseUrl,
requestedAmount: Amounts.toString(r.initiallyRequestedAmount),
reservePub: r.reservePub,
reserveType,
bankWithdrawStatusUrl: r.bankWithdrawStatusUrl,
},
timestamp: r.created,
type: "reserve-created",
explicit: false,
});
if (r.timestampConfirmed) {
history.push({
detail: {
exchangeBaseUrl: r.exchangeBaseUrl,
requestedAmount: Amounts.toString(r.initiallyRequestedAmount),
reservePub: r.reservePub,
reserveType,
bankWithdrawStatusUrl: r.bankWithdrawStatusUrl,
},
timestamp: r.created,
type: "reserve-confirmed",
explicit: false,
});
}
}
const tips: TipRecord[] = await oneShotIter(this.db, Stores.tips).toArray();
for (const tip of tips) {
history.push({
detail: {
accepted: tip.accepted,
amount: tip.amount,
merchantDomain: tip.merchantDomain,
tipId: tip.tipId,
},
timestamp: tip.timestamp,
explicit: false,
type: "tip",
});
}
await oneShotIter(this.db, Stores.exchanges).forEach(exchange => {
history.push({
type: "exchange-added",
explicit: false,
timestamp: exchange.timestampAdded,
detail: {
exchangeBaseUrl: exchange.baseUrl,
},
});
});
history.sort((h1, h2) => Math.sign(h1.timestamp.t_ms - h2.timestamp.t_ms));
return { history };
}
async getPendingOperations(): Promise {
const pendingOperations: PendingOperationInfo[] = [];
const exchanges = await this.getExchanges();
for (let e of exchanges) {
switch (e.updateStatus) {
case ExchangeUpdateStatus.FINISHED:
if (e.lastError) {
pendingOperations.push({
type: "bug",
message:
"Exchange record is in FINISHED state but has lastError set",
details: {
exchangeBaseUrl: e.baseUrl,
},
});
}
if (!e.details) {
pendingOperations.push({
type: "bug",
message:
"Exchange record does not have details, but no update in progress.",
details: {
exchangeBaseUrl: e.baseUrl,
},
});
}
if (!e.wireInfo) {
pendingOperations.push({
type: "bug",
message:
"Exchange record does not have wire info, but no update in progress.",
details: {
exchangeBaseUrl: e.baseUrl,
},
});
}
break;
case ExchangeUpdateStatus.FETCH_KEYS:
pendingOperations.push({
type: "exchange-update",
stage: "fetch-keys",
exchangeBaseUrl: e.baseUrl,
lastError: e.lastError,
reason: e.updateReason || "unknown",
});
break;
case ExchangeUpdateStatus.FETCH_WIRE:
pendingOperations.push({
type: "exchange-update",
stage: "fetch-wire",
exchangeBaseUrl: e.baseUrl,
lastError: e.lastError,
reason: e.updateReason || "unknown",
});
break;
default:
pendingOperations.push({
type: "bug",
message: "Unknown exchangeUpdateStatus",
details: {
exchangeBaseUrl: e.baseUrl,
exchangeUpdateStatus: e.updateStatus,
},
});
break;
}
}
await oneShotIter(this.db, Stores.reserves).forEach(reserve => {
const reserveType = reserve.bankWithdrawStatusUrl
? "taler-bank"
: "manual";
switch (reserve.reserveStatus) {
case ReserveRecordStatus.DORMANT:
// nothing to report as pending
break;
case ReserveRecordStatus.WITHDRAWING:
case ReserveRecordStatus.UNCONFIRMED:
case ReserveRecordStatus.QUERYING_STATUS:
case ReserveRecordStatus.REGISTERING_BANK:
pendingOperations.push({
type: "reserve",
stage: reserve.reserveStatus,
timestampCreated: reserve.created,
reserveType,
reservePub: reserve.reservePub,
});
break;
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
pendingOperations.push({
type: "reserve",
stage: reserve.reserveStatus,
timestampCreated: reserve.created,
reserveType,
reservePub: reserve.reservePub,
bankWithdrawConfirmUrl: reserve.bankWithdrawConfirmUrl,
});
break;
default:
pendingOperations.push({
type: "bug",
message: "Unknown reserve record status",
details: {
reservePub: reserve.reservePub,
reserveStatus: reserve.reserveStatus,
},
});
break;
}
});
await oneShotIter(this.db, Stores.refresh).forEach(r => {
if (r.finished) {
return;
}
let refreshStatus: string;
if (r.norevealIndex === undefined) {
refreshStatus = "melt";
} else {
refreshStatus = "reveal";
}
pendingOperations.push({
type: "refresh",
oldCoinPub: r.meltCoinPub,
refreshStatus,
refreshOutputSize: r.newDenoms.length,
refreshSessionId: r.refreshSessionId,
});
});
await oneShotIter(this.db, Stores.planchets).forEach(pc => {
pendingOperations.push({
type: "planchet",
coinPub: pc.coinPub,
reservePub: pc.reservePub,
});
});
await oneShotIter(this.db, Stores.coins).forEach(coin => {
if (coin.status == CoinStatus.Dirty) {
pendingOperations.push({
type: "dirty-coin",
coinPub: coin.coinPub,
});
}
});
await oneShotIter(this.db, Stores.withdrawalSession).forEach(ws => {
const numCoinsWithdrawn = ws.withdrawn.reduce(
(a, x) => a + (x ? 1 : 0),
0,
);
const numCoinsTotal = ws.withdrawn.length;
if (numCoinsWithdrawn < numCoinsTotal) {
pendingOperations.push({
type: "withdraw",
numCoinsTotal,
numCoinsWithdrawn,
reservePub: ws.reservePub,
withdrawSessionId: ws.withdrawSessionId,
});
}
});
await oneShotIter(this.db, Stores.proposals).forEach(proposal => {
if (proposal.proposalStatus == ProposalStatus.PROPOSED) {
pendingOperations.push({
type: "proposal",
merchantBaseUrl: proposal.contractTerms.merchant_base_url,
proposalId: proposal.proposalId,
proposalTimestamp: proposal.timestamp,
});
}
});
return {
pendingOperations,
};
}
async getDenoms(exchangeUrl: string): Promise {
const denoms = await oneShotIterIndex(
this.db,
Stores.denominations.exchangeBaseUrlIndex,
exchangeUrl,
).toArray();
return denoms;
}
async getProposal(proposalId: string): Promise {
const proposal = await oneShotGet(this.db, Stores.proposals, proposalId);
return proposal;
}
async getExchanges(): Promise {
return await oneShotIter(this.db, Stores.exchanges).toArray();
}
async getCurrencies(): Promise {
return await oneShotIter(this.db, Stores.currencies).toArray();
}
async updateCurrency(currencyRecord: CurrencyRecord): Promise {
Wallet.enableTracing && console.log("updating currency to", currencyRecord);
await oneShotPut(this.db, Stores.currencies, currencyRecord);
this.notifier.notify();
}
async getReserves(exchangeBaseUrl: string): Promise {
return await oneShotIter(this.db, Stores.reserves).filter(
r => r.exchangeBaseUrl === exchangeBaseUrl,
);
}
async getCoinsForExchange(exchangeBaseUrl: string): Promise {
return await oneShotIter(this.db, Stores.coins).filter(
c => c.exchangeBaseUrl === exchangeBaseUrl,
);
}
async getCoins(): Promise {
return await oneShotIter(this.db, Stores.coins).toArray();
}
async getPlanchets(exchangeBaseUrl: string): Promise {
return await oneShotIter(this.db, Stores.planchets).filter(
c => c.exchangeBaseUrl === exchangeBaseUrl,
);
}
private async hashContract(contract: ContractTerms): Promise {
return this.cryptoApi.hashString(canonicalJson(contract));
}
async payback(coinPub: string): Promise {
let coin = await oneShotGet(this.db, Stores.coins, coinPub);
if (!coin) {
throw Error(`Coin ${coinPub} not found, can't request payback`);
}
const reservePub = coin.reservePub;
if (!reservePub) {
throw Error(`Can't request payback for a refreshed coin`);
}
const reserve = await oneShotGet(this.db, Stores.reserves, reservePub);
if (!reserve) {
throw Error(`Reserve of coin ${coinPub} not found`);
}
switch (coin.status) {
case CoinStatus.Dormant:
throw Error(`Can't do payback for coin ${coinPub} since it's dormant`);
}
coin.status = CoinStatus.Dormant;
// Even if we didn't get the payback yet, we suspend withdrawal, since
// technically we might update reserve status before we get the response
// from the reserve for the payback request.
reserve.hasPayback = true;
await runWithWriteTransaction(
this.db,
[Stores.coins, Stores.reserves],
async tx => {
await tx.put(Stores.coins, coin!!);
await tx.put(Stores.reserves, reserve);
},
);
this.notifier.notify();
const paybackRequest = await this.cryptoApi.createPaybackRequest(coin);
const reqUrl = new URI("payback").absoluteTo(coin.exchangeBaseUrl);
const resp = await this.http.postJson(reqUrl.href(), paybackRequest);
if (resp.status !== 200) {
throw Error();
}
const paybackConfirmation = PaybackConfirmation.checked(resp.responseJson);
if (paybackConfirmation.reserve_pub !== coin.reservePub) {
throw Error(`Coin's reserve doesn't match reserve on payback`);
}
coin = await oneShotGet(this.db, Stores.coins, coinPub);
if (!coin) {
throw Error(`Coin ${coinPub} not found, can't confirm payback`);
}
coin.status = CoinStatus.Dormant;
await oneShotPut(this.db, Stores.coins, coin);
this.notifier.notify();
await this.updateReserve(reservePub!);
}
private async denominationRecordFromKeys(
exchangeBaseUrl: string,
denomIn: Denomination,
): Promise {
const denomPubHash = await this.cryptoApi.hashDenomPub(denomIn.denom_pub);
const d: DenominationRecord = {
denomPub: denomIn.denom_pub,
denomPubHash,
exchangeBaseUrl,
feeDeposit: Amounts.parseOrThrow(denomIn.fee_deposit),
feeRefresh: Amounts.parseOrThrow(denomIn.fee_refresh),
feeRefund: Amounts.parseOrThrow(denomIn.fee_refund),
feeWithdraw: Amounts.parseOrThrow(denomIn.fee_withdraw),
isOffered: true,
masterSig: denomIn.master_sig,
stampExpireDeposit: extractTalerStampOrThrow(
denomIn.stamp_expire_deposit,
),
stampExpireLegal: extractTalerStampOrThrow(denomIn.stamp_expire_legal),
stampExpireWithdraw: extractTalerStampOrThrow(
denomIn.stamp_expire_withdraw,
),
stampStart: extractTalerStampOrThrow(denomIn.stamp_start),
status: DenominationStatus.Unverified,
value: Amounts.parseOrThrow(denomIn.value),
};
return d;
}
async withdrawPaybackReserve(reservePub: string): Promise {
const reserve = await oneShotGet(this.db, Stores.reserves, reservePub);
if (!reserve) {
throw Error(`Reserve ${reservePub} does not exist`);
}
reserve.hasPayback = false;
await oneShotPut(this.db, Stores.reserves, reserve);
this.depleteReserve(reserve.reservePub).catch(e => {
console.error("Error depleting reserve after payback", e);
});
}
async getPaybackReserves(): Promise {
return await oneShotIter(this.db, Stores.reserves).filter(
r => r.hasPayback,
);
}
/**
* Stop ongoing processing.
*/
stop() {
//this.timerGroup.stopCurrentAndFutureTimers();
this.cryptoApi.stop();
}
async getSenderWireInfos(): Promise {
const m: { [url: string]: Set } = {};
await oneShotIter(this.db, Stores.exchanges).forEach(x => {
const wi = x.wireInfo;
if (!wi) {
return;
}
const s = (m[x.baseUrl] = m[x.baseUrl] || new Set());
Object.keys(wi.feesForType).map(k => s.add(k));
});
Wallet.enableTracing && console.log(m);
const exchangeWireTypes: { [url: string]: string[] } = {};
Object.keys(m).map(e => {
exchangeWireTypes[e] = Array.from(m[e]);
});
const senderWiresSet: Set = new Set();
await oneShotIter(this.db, Stores.senderWires).forEach(x => {
senderWiresSet.add(x.paytoUri);
});
const senderWires: string[] = Array.from(senderWiresSet);
return {
exchangeWireTypes,
senderWires,
};
}
/**
* Trigger paying coins back into the user's account.
*/
async returnCoins(req: ReturnCoinsRequest): Promise {
Wallet.enableTracing && console.log("got returnCoins request", req);
const wireType = (req.senderWire as any).type;
Wallet.enableTracing && console.log("wireType", wireType);
if (!wireType || typeof wireType !== "string") {
console.error(`wire type must be a non-empty string, not ${wireType}`);
return;
}
const stampSecNow = Math.floor(new Date().getTime() / 1000);
const exchange = await this.findExchange(req.exchange);
if (!exchange) {
console.error(`Exchange ${req.exchange} not known to the wallet`);
return;
}
const exchangeDetails = exchange.details;
if (!exchangeDetails) {
throw Error("exchange information needs to be updated first.");
}
Wallet.enableTracing && console.log("selecting coins for return:", req);
const cds = await this.getCoinsForReturn(req.exchange, req.amount);
Wallet.enableTracing && console.log(cds);
if (!cds) {
throw Error("coin return impossible, can't select coins");
}
const { priv, pub } = await this.cryptoApi.createEddsaKeypair();
const wireHash = await this.cryptoApi.hashString(
canonicalJson(req.senderWire),
);
const contractTerms: ContractTerms = {
H_wire: wireHash,
amount: Amounts.toString(req.amount),
auditors: [],
exchanges: [
{ master_pub: exchangeDetails.masterPublicKey, url: exchange.baseUrl },
],
extra: {},
fulfillment_url: "",
locations: [],
max_fee: Amounts.toString(req.amount),
merchant: {},
merchant_pub: pub,
order_id: "none",
pay_deadline: `/Date(${stampSecNow + 30 * 5})/`,
wire_transfer_deadline: `/Date(${stampSecNow + 60 * 5})/`,
merchant_base_url: "taler://return-to-account",
products: [],
refund_deadline: `/Date(${stampSecNow + 60 * 5})/`,
timestamp: `/Date(${stampSecNow})/`,
wire_method: wireType,
};
const contractTermsHash = await this.cryptoApi.hashString(
canonicalJson(contractTerms),
);
const payCoinInfo = await this.cryptoApi.signDeposit(
contractTerms,
cds,
Amounts.parseOrThrow(contractTerms.amount),
);
Wallet.enableTracing && console.log("pci", payCoinInfo);
const coins = payCoinInfo.sigs.map(s => ({ coinPaySig: s }));
const coinsReturnRecord: CoinsReturnRecord = {
coins,
contractTerms,
contractTermsHash,
exchange: exchange.baseUrl,
merchantPriv: priv,
wire: req.senderWire,
};
await runWithWriteTransaction(
this.db,
[Stores.coinsReturns, Stores.coins],
async tx => {
await tx.put(Stores.coinsReturns, coinsReturnRecord);
for (let c of payCoinInfo.updatedCoins) {
await tx.put(Stores.coins, c);
}
},
);
this.badge.showNotification();
this.notifier.notify();
this.depositReturnedCoins(coinsReturnRecord);
}
async depositReturnedCoins(
coinsReturnRecord: CoinsReturnRecord,
): Promise {
for (const c of coinsReturnRecord.coins) {
if (c.depositedSig) {
continue;
}
const req = {
H_wire: coinsReturnRecord.contractTerms.H_wire,
coin_pub: c.coinPaySig.coin_pub,
coin_sig: c.coinPaySig.coin_sig,
contribution: c.coinPaySig.contribution,
denom_pub: c.coinPaySig.denom_pub,
h_contract_terms: coinsReturnRecord.contractTermsHash,
merchant_pub: coinsReturnRecord.contractTerms.merchant_pub,
pay_deadline: coinsReturnRecord.contractTerms.pay_deadline,
refund_deadline: coinsReturnRecord.contractTerms.refund_deadline,
timestamp: coinsReturnRecord.contractTerms.timestamp,
ub_sig: c.coinPaySig.ub_sig,
wire: coinsReturnRecord.wire,
wire_transfer_deadline: coinsReturnRecord.contractTerms.pay_deadline,
};
Wallet.enableTracing && console.log("req", req);
const reqUrl = new URI("deposit").absoluteTo(coinsReturnRecord.exchange);
const resp = await this.http.postJson(reqUrl.href(), req);
if (resp.status !== 200) {
console.error("deposit failed due to status code", resp);
continue;
}
const respJson = resp.responseJson;
if (respJson.status !== "DEPOSIT_OK") {
console.error("deposit failed", resp);
continue;
}
if (!respJson.sig) {
console.error("invalid 'sig' field", resp);
continue;
}
// FIXME: verify signature
// For every successful deposit, we replace the old record with an updated one
const currentCrr = await oneShotGet(
this.db,
Stores.coinsReturns,
coinsReturnRecord.contractTermsHash,
);
if (!currentCrr) {
console.error("database inconsistent");
continue;
}
for (const nc of currentCrr.coins) {
if (nc.coinPaySig.coin_pub === c.coinPaySig.coin_pub) {
nc.depositedSig = respJson.sig;
}
}
await oneShotPut(this.db, Stores.coinsReturns, currentCrr);
this.notifier.notify();
}
}
private async acceptRefundResponse(
refundResponse: MerchantRefundResponse,
): Promise {
const refundPermissions = refundResponse.refund_permissions;
if (!refundPermissions.length) {
console.warn("got empty refund list");
throw Error("empty refund");
}
/**
* Add refund to purchase if not already added.
*/
function f(t: PurchaseRecord | undefined): PurchaseRecord | undefined {
if (!t) {
console.error("purchase not found, not adding refunds");
return;
}
t.timestamp_refund = getTimestampNow();
for (const perm of refundPermissions) {
if (
!t.refundsPending[perm.merchant_sig] &&
!t.refundsDone[perm.merchant_sig]
) {
t.refundsPending[perm.merchant_sig] = perm;
}
}
return t;
}
const hc = refundResponse.h_contract_terms;
// Add the refund permissions to the purchase within a DB transaction
await oneShotMutate(this.db, Stores.purchases, hc, f);
this.notifier.notify();
await this.submitRefunds(hc);
return hc;
}
/**
* Accept a refund, return the contract hash for the contract
* that was involved in the refund.
*/
async applyRefund(talerRefundUri: string): Promise {
const parseResult = parseRefundUri(talerRefundUri);
if (!parseResult) {
throw Error("invalid refund URI");
}
const refundUrl = parseResult.refundUrl;
Wallet.enableTracing && console.log("processing refund");
let resp;
try {
resp = await this.http.get(refundUrl);
} catch (e) {
console.error("error downloading refund permission", e);
throw e;
}
const refundResponse = MerchantRefundResponse.checked(resp.responseJson);
return this.acceptRefundResponse(refundResponse);
}
private async submitRefunds(contractTermsHash: string): Promise {
const purchase = await oneShotGet(
this.db,
Stores.purchases,
contractTermsHash,
);
if (!purchase) {
console.error(
"not submitting refunds, contract terms not found:",
contractTermsHash,
);
return;
}
const pendingKeys = Object.keys(purchase.refundsPending);
if (pendingKeys.length === 0) {
return;
}
for (const pk of pendingKeys) {
const perm = purchase.refundsPending[pk];
const req: RefundRequest = {
coin_pub: perm.coin_pub,
h_contract_terms: purchase.contractTermsHash,
merchant_pub: purchase.contractTerms.merchant_pub,
merchant_sig: perm.merchant_sig,
refund_amount: perm.refund_amount,
refund_fee: perm.refund_fee,
rtransaction_id: perm.rtransaction_id,
};
console.log("sending refund permission", perm);
// FIXME: not correct once we support multiple exchanges per payment
const exchangeUrl = purchase.payReq.coins[0].exchange_url;
const reqUrl = new URI("refund").absoluteTo(exchangeUrl);
const resp = await this.http.postJson(reqUrl.href(), req);
if (resp.status !== 200) {
console.error("refund failed", resp);
continue;
}
// Transactionally mark successful refunds as done
const transformPurchase = (
t: PurchaseRecord | undefined,
): PurchaseRecord | undefined => {
if (!t) {
console.warn("purchase not found, not updating refund");
return;
}
if (t.refundsPending[pk]) {
t.refundsDone[pk] = t.refundsPending[pk];
delete t.refundsPending[pk];
}
return t;
};
const transformCoin = (
c: CoinRecord | undefined,
): CoinRecord | undefined => {
if (!c) {
console.warn("coin not found, can't apply refund");
return;
}
const refundAmount = Amounts.parseOrThrow(perm.refund_amount);
const refundFee = Amounts.parseOrThrow(perm.refund_fee);
c.status = CoinStatus.Dirty;
c.currentAmount = Amounts.add(c.currentAmount, refundAmount).amount;
c.currentAmount = Amounts.sub(c.currentAmount, refundFee).amount;
return c;
};
await runWithWriteTransaction(
this.db,
[Stores.purchases, Stores.coins],
async tx => {
await tx.mutate(
Stores.purchases,
contractTermsHash,
transformPurchase,
);
await tx.mutate(Stores.coins, perm.coin_pub, transformCoin);
},
);
this.refresh(perm.coin_pub);
}
this.badge.showNotification();
this.notifier.notify();
}
async getPurchase(
contractTermsHash: string,
): Promise {
return oneShotGet(this.db, Stores.purchases, contractTermsHash);
}
async getFullRefundFees(
refundPermissions: MerchantRefundPermission[],
): Promise {
if (refundPermissions.length === 0) {
throw Error("no refunds given");
}
const coin0 = await oneShotGet(
this.db,
Stores.coins,
refundPermissions[0].coin_pub,
);
if (!coin0) {
throw Error("coin not found");
}
let feeAcc = Amounts.getZero(
Amounts.parseOrThrow(refundPermissions[0].refund_amount).currency,
);
const denoms = await oneShotIterIndex(
this.db,
Stores.denominations.exchangeBaseUrlIndex,
coin0.exchangeBaseUrl,
).toArray();
for (const rp of refundPermissions) {
const coin = await oneShotGet(this.db, Stores.coins, rp.coin_pub);
if (!coin) {
throw Error("coin not found");
}
const denom = await oneShotGet(this.db, Stores.denominations, [
coin0.exchangeBaseUrl,
coin.denomPub,
]);
if (!denom) {
throw Error(`denom not found (${coin.denomPub})`);
}
// FIXME: this assumes that the refund already happened.
// When it hasn't, the refresh cost is inaccurate. To fix this,
// we need introduce a flag to tell if a coin was refunded or
// refreshed normally (and what about incremental refunds?)
const refundAmount = Amounts.parseOrThrow(rp.refund_amount);
const refundFee = Amounts.parseOrThrow(rp.refund_fee);
const refreshCost = getTotalRefreshCost(
denoms,
denom,
Amounts.sub(refundAmount, refundFee).amount,
);
feeAcc = Amounts.add(feeAcc, refreshCost, refundFee).amount;
}
return feeAcc;
}
async acceptTip(talerTipUri: string): Promise {
const { tipId, merchantOrigin } = await this.getTipStatus(talerTipUri);
let tipRecord = await oneShotGet(this.db, Stores.tips, [
tipId,
merchantOrigin,
]);
if (!tipRecord) {
throw Error("tip not in database");
}
tipRecord.accepted = true;
await oneShotPut(this.db, Stores.tips, tipRecord);
if (tipRecord.pickedUp) {
console.log("tip already picked up");
return;
}
await this.updateExchangeFromUrl(tipRecord.exchangeUrl);
const denomsForWithdraw = await this.getVerifiedWithdrawDenomList(
tipRecord.exchangeUrl,
tipRecord.amount,
);
if (!tipRecord.planchets) {
const planchets = await Promise.all(
denomsForWithdraw.map(d => this.cryptoApi.createTipPlanchet(d)),
);
const coinPubs: string[] = planchets.map(x => x.coinPub);
await oneShotMutate(this.db, Stores.tips, [tipId, merchantOrigin], r => {
if (!r.planchets) {
r.planchets = planchets;
r.coinPubs = coinPubs;
}
return r;
});
this.notifier.notify();
}
tipRecord = await oneShotGet(this.db, Stores.tips, [tipId, merchantOrigin]);
if (!tipRecord) {
throw Error("tip not in database");
}
if (!tipRecord.planchets) {
throw Error("invariant violated");
}
console.log("got planchets for tip!");
// Planchets in the form that the merchant expects
const planchetsDetail: TipPlanchetDetail[] = tipRecord.planchets.map(p => ({
coin_ev: p.coinEv,
denom_pub_hash: p.denomPubHash,
}));
let merchantResp;
try {
const req = { planchets: planchetsDetail, tip_id: tipId };
merchantResp = await this.http.postJson(tipRecord.pickupUrl, req);
console.log("got merchant resp:", merchantResp);
} catch (e) {
console.log("tipping failed", e);
throw e;
}
const response = TipResponse.checked(merchantResp.responseJson);
if (response.reserve_sigs.length !== tipRecord.planchets.length) {
throw Error("number of tip responses does not match requested planchets");
}
for (let i = 0; i < tipRecord.planchets.length; i++) {
const tipPlanchet = tipRecord.planchets[i];
const planchet: PlanchetRecord = {
blindingKey: tipPlanchet.blindingKey,
coinEv: tipPlanchet.coinEv,
coinPriv: tipPlanchet.coinPriv,
coinPub: tipPlanchet.coinPub,
coinValue: tipPlanchet.coinValue,
denomPub: tipPlanchet.denomPub,
denomPubHash: tipPlanchet.denomPubHash,
exchangeBaseUrl: tipRecord.exchangeUrl,
isFromTip: true,
reservePub: response.reserve_pub,
withdrawSig: response.reserve_sigs[i].reserve_sig,
coinIndex: -1,
withdrawSessionId: "",
};
await oneShotPut(this.db, Stores.planchets, planchet);
await this.processPlanchet(planchet.coinPub);
}
tipRecord.pickedUp = true;
await oneShotPut(this.db, Stores.tips, tipRecord);
this.notifier.notify();
this.badge.showNotification();
return;
}
async getTipStatus(talerTipUri: string): Promise {
const res = parseTipUri(talerTipUri);
if (!res) {
throw Error("invalid taler://tip URI");
}
const tipStatusUrl = new URI(res.tipPickupUrl).href();
console.log("checking tip status from", tipStatusUrl);
const merchantResp = await this.http.get(tipStatusUrl);
console.log("resp:", merchantResp.responseJson);
const tipPickupStatus = TipPickupGetResponse.checked(
merchantResp.responseJson,
);
console.log("status", tipPickupStatus);
let amount = Amounts.parseOrThrow(tipPickupStatus.amount);
let tipRecord = await oneShotGet(this.db, Stores.tips, [
res.tipId,
res.merchantOrigin,
]);
if (!tipRecord) {
const withdrawDetails = await this.getWithdrawDetailsForAmount(
tipPickupStatus.exchange_url,
amount,
);
tipRecord = {
accepted: false,
amount,
coinPubs: [],
deadline: getTalerStampSec(tipPickupStatus.stamp_expire)!,
exchangeUrl: tipPickupStatus.exchange_url,
merchantDomain: res.merchantOrigin,
nextUrl: undefined,
pickedUp: false,
planchets: undefined,
response: undefined,
timestamp: getTimestampNow(),
tipId: res.tipId,
pickupUrl: res.tipPickupUrl,
totalFees: Amounts.add(
withdrawDetails.overhead,
withdrawDetails.withdrawFee,
).amount,
};
await oneShotPut(this.db, Stores.tips, tipRecord);
}
const tipStatus: TipStatus = {
accepted: !!tipRecord && tipRecord.accepted,
amount: Amounts.parseOrThrow(tipPickupStatus.amount),
amountLeft: Amounts.parseOrThrow(tipPickupStatus.amount_left),
exchangeUrl: tipPickupStatus.exchange_url,
nextUrl: tipPickupStatus.extra.next_url,
merchantOrigin: res.merchantOrigin,
tipId: res.tipId,
expirationTimestamp: getTalerStampSec(tipPickupStatus.stamp_expire)!,
timestamp: getTalerStampSec(tipPickupStatus.stamp_created)!,
totalFees: tipRecord.totalFees,
};
return tipStatus;
}
async abortFailedPayment(contractTermsHash: string): Promise {
const purchase = await oneShotGet(
this.db,
Stores.purchases,
contractTermsHash,
);
if (!purchase) {
throw Error("Purchase not found, unable to abort with refund");
}
if (purchase.finished) {
throw Error("Purchase already finished, not aborting");
}
if (purchase.abortDone) {
console.warn("abort requested on already aborted purchase");
return;
}
purchase.abortRequested = true;
// From now on, we can't retry payment anymore,
// so mark this in the DB in case the /pay abort
// does not complete on the first try.
await oneShotPut(this.db, Stores.purchases, purchase);
let resp;
const abortReq = { ...purchase.payReq, mode: "abort-refund" };
const payUrl = new URI("pay")
.absoluteTo(purchase.contractTerms.merchant_base_url)
.href();
try {
resp = await this.http.postJson(payUrl, abortReq);
} catch (e) {
// Gives the user the option to retry / abort and refresh
console.log("aborting payment failed", e);
throw e;
}
const refundResponse = MerchantRefundResponse.checked(resp.responseJson);
await this.acceptRefundResponse(refundResponse);
await runWithWriteTransaction(this.db, [Stores.purchases], async tx => {
const p = await tx.get(Stores.purchases, purchase.contractTermsHash);
if (!p) {
return;
}
p.abortDone = true;
await tx.put(Stores.purchases, p);
});
}
public async handleNotifyReserve() {
const reserves = await oneShotIter(this.db, Stores.reserves).toArray();
for (const r of reserves) {
if (r.reserveStatus === ReserveRecordStatus.WAIT_CONFIRM_BANK) {
try {
this.processReserveBankStatus(r.reservePub);
} catch (e) {
console.error(e);
}
}
}
}
/**
* Remove unreferenced / expired data from the wallet's database
* based on the current system time.
*/
async collectGarbage() {
// FIXME(#5845)
// We currently do not garbage-collect the wallet database. This might change
// after the feature has been properly re-designed, and we have come up with a
// strategy to test it.
}
/**
* Get information about a withdrawal from
* a taler://withdraw URI.
*/
async getWithdrawalInfo(
talerWithdrawUri: string,
): Promise {
const uriResult = parseWithdrawUri(talerWithdrawUri);
if (!uriResult) {
throw Error("can't parse URL");
}
const resp = await this.http.get(uriResult.statusUrl);
console.log("resp:", resp.responseJson);
const status = WithdrawOperationStatusResponse.checked(resp.responseJson);
return {
amount: Amounts.parseOrThrow(status.amount),
confirmTransferUrl: status.confirm_transfer_url,
extractedStatusUrl: uriResult.statusUrl,
selectionDone: status.selection_done,
senderWire: status.sender_wire,
suggestedExchange: status.suggested_exchange,
transferDone: status.transfer_done,
wireTypes: status.wire_types,
};
}
async acceptWithdrawal(
talerWithdrawUri: string,
selectedExchange: string,
): Promise {
const withdrawInfo = await this.getWithdrawalInfo(talerWithdrawUri);
const exchangeWire = await this.getExchangePaytoUri(
selectedExchange,
withdrawInfo.wireTypes,
);
const reserve = await this.createReserve({
amount: withdrawInfo.amount,
bankWithdrawStatusUrl: withdrawInfo.extractedStatusUrl,
exchange: selectedExchange,
senderWire: withdrawInfo.senderWire,
exchangeWire: exchangeWire,
});
// We do this here, as the reserve should be registered before we return,
// so that we can redirect the user to the bank's status page.
await this.processReserveBankStatus(reserve.reservePub);
console.log("acceptWithdrawal: returning");
return {
reservePub: reserve.reservePub,
confirmTransferUrl: withdrawInfo.confirmTransferUrl,
};
}
async getPurchaseDetails(hc: string): Promise {
const purchase = await oneShotGet(this.db, Stores.purchases, hc);
if (!purchase) {
throw Error("unknown purchase");
}
const refundsDoneAmounts = Object.values(purchase.refundsDone).map(x =>
Amounts.parseOrThrow(x.refund_amount),
);
const refundsPendingAmounts = Object.values(
purchase.refundsPending,
).map(x => Amounts.parseOrThrow(x.refund_amount));
const totalRefundAmount = Amounts.sum([
...refundsDoneAmounts,
...refundsPendingAmounts,
]).amount;
const refundsDoneFees = Object.values(purchase.refundsDone).map(x =>
Amounts.parseOrThrow(x.refund_amount),
);
const refundsPendingFees = Object.values(purchase.refundsPending).map(x =>
Amounts.parseOrThrow(x.refund_amount),
);
const totalRefundFees = Amounts.sum([
...refundsDoneFees,
...refundsPendingFees,
]).amount;
const totalFees = totalRefundFees;
return {
contractTerms: purchase.contractTerms,
hasRefund: purchase.timestamp_refund !== undefined,
totalRefundAmount: totalRefundAmount,
totalRefundAndRefreshFees: totalFees,
};
}
clearNotification(): void {
this.badge.clearNotification();
}
benchmarkCrypto(repetitions: number): Promise {
return this.cryptoApi.benchmark(repetitions);
}
}