2015-12-25 22:42:14 +01:00
|
|
|
/*
|
|
|
|
This file is part of TALER
|
|
|
|
(C) 2015 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
|
2016-07-07 17:59:29 +02:00
|
|
|
TALER; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
|
2015-12-25 22:42:14 +01:00
|
|
|
*/
|
|
|
|
|
2016-01-05 15:42:46 +01:00
|
|
|
/**
|
|
|
|
* High-level wallet operations that should be indepentent from the underlying
|
|
|
|
* browser extension interface.
|
|
|
|
*/
|
|
|
|
|
2017-05-24 16:52:00 +02:00
|
|
|
/**
|
|
|
|
* Imports.
|
|
|
|
*/
|
2019-08-15 19:10:23 +02:00
|
|
|
import { CryptoApi, CryptoWorkerFactory } from "./crypto/cryptoApi";
|
2017-05-28 01:10:54 +02:00
|
|
|
import {
|
|
|
|
amountToPretty,
|
|
|
|
canonicalJson,
|
|
|
|
canonicalizeBaseUrl,
|
|
|
|
getTalerStampSec,
|
2018-01-04 11:35:04 +01:00
|
|
|
strcmp,
|
2017-05-28 01:10:54 +02:00
|
|
|
} from "./helpers";
|
2019-06-26 15:30:32 +02:00
|
|
|
import { HttpRequestLibrary, RequestException } from "./http";
|
2017-06-04 20:16:09 +02:00
|
|
|
import * as LibtoolVersion from "./libtoolVersion";
|
2017-05-28 01:10:54 +02:00
|
|
|
import {
|
|
|
|
AbortTransaction,
|
|
|
|
JoinLeftResult,
|
|
|
|
JoinResult,
|
|
|
|
QueryRoot,
|
|
|
|
} from "./query";
|
2018-01-03 14:42:06 +01:00
|
|
|
import { TimerGroup } from "./timer";
|
|
|
|
|
|
|
|
import { AmountJson } from "./amounts";
|
|
|
|
import * as Amounts from "./amounts";
|
|
|
|
|
2018-01-04 11:35:04 +01:00
|
|
|
import URI = require("urijs");
|
|
|
|
|
2016-05-24 01:53:56 +02:00
|
|
|
import {
|
2017-05-28 01:10:54 +02:00
|
|
|
CoinRecord,
|
|
|
|
CoinStatus,
|
2018-01-04 11:35:04 +01:00
|
|
|
CoinsReturnRecord,
|
2017-05-28 01:10:54 +02:00
|
|
|
CurrencyRecord,
|
|
|
|
DenominationRecord,
|
|
|
|
DenominationStatus,
|
2016-11-15 15:07:17 +01:00
|
|
|
ExchangeRecord,
|
|
|
|
PreCoinRecord,
|
2018-01-17 03:49:54 +01:00
|
|
|
ProposalDownloadRecord,
|
2017-08-30 17:08:54 +02:00
|
|
|
PurchaseRecord,
|
2017-12-09 03:37:21 +01:00
|
|
|
RefreshPreCoinRecord,
|
2016-11-15 15:07:17 +01:00
|
|
|
RefreshSessionRecord,
|
2018-01-03 14:42:06 +01:00
|
|
|
ReserveRecord,
|
2018-01-04 11:35:04 +01:00
|
|
|
Stores,
|
2018-01-03 14:42:06 +01:00
|
|
|
TipRecord,
|
|
|
|
WireFee,
|
|
|
|
} from "./dbTypes";
|
|
|
|
import {
|
|
|
|
Auditor,
|
|
|
|
ContractTerms,
|
|
|
|
Denomination,
|
|
|
|
ExchangeHandle,
|
2019-05-08 04:53:26 +02:00
|
|
|
ExchangeWireJson,
|
2018-01-04 11:35:04 +01:00
|
|
|
KeysJson,
|
2018-01-29 16:41:17 +01:00
|
|
|
MerchantRefundPermission,
|
|
|
|
MerchantRefundResponse,
|
2018-01-03 14:42:06 +01:00
|
|
|
PayReq,
|
|
|
|
PaybackConfirmation,
|
2018-01-17 03:49:54 +01:00
|
|
|
Proposal,
|
2018-01-29 16:41:17 +01:00
|
|
|
RefundRequest,
|
2018-01-29 22:58:47 +01:00
|
|
|
ReserveStatus,
|
2018-01-03 14:42:06 +01:00
|
|
|
TipPlanchetDetail,
|
|
|
|
TipResponse,
|
2019-08-28 02:49:27 +02:00
|
|
|
WithdrawOperationStatusResponse,
|
2019-08-30 17:27:59 +02:00
|
|
|
TipPickupGetResponse,
|
2018-01-03 14:42:06 +01:00
|
|
|
} from "./talerTypes";
|
|
|
|
import {
|
2018-01-04 11:35:04 +01:00
|
|
|
Badge,
|
2018-09-20 02:56:13 +02:00
|
|
|
BenchmarkResult,
|
2018-01-03 14:42:06 +01:00
|
|
|
CoinSelectionResult,
|
|
|
|
CoinWithDenom,
|
|
|
|
ConfirmPayResult,
|
|
|
|
ConfirmReserveRequest,
|
|
|
|
CreateReserveRequest,
|
|
|
|
CreateReserveResponse,
|
|
|
|
HistoryRecord,
|
2018-01-18 02:50:18 +01:00
|
|
|
NextUrlResult,
|
2018-01-03 14:42:06 +01:00
|
|
|
Notifier,
|
|
|
|
PayCoinInfo,
|
2016-11-16 01:59:39 +01:00
|
|
|
ReserveCreationInfo,
|
2017-08-14 04:16:12 +02:00
|
|
|
ReturnCoinsRequest,
|
|
|
|
SenderWireInfos,
|
2017-11-30 04:07:36 +01:00
|
|
|
TipStatus,
|
2016-11-13 08:16:12 +01:00
|
|
|
WalletBalance,
|
|
|
|
WalletBalanceEntry,
|
2019-08-20 17:58:01 +02:00
|
|
|
PreparePayResult,
|
2019-08-28 02:49:27 +02:00
|
|
|
DownloadedWithdrawInfo,
|
2019-08-29 23:12:55 +02:00
|
|
|
WithdrawDetails,
|
|
|
|
AcceptWithdrawalResponse,
|
2019-08-31 13:27:12 +02:00
|
|
|
PurchaseDetails,
|
2018-01-03 14:42:06 +01:00
|
|
|
} from "./walletTypes";
|
2019-08-01 23:21:15 +02:00
|
|
|
import { openPromise } from "./promiseUtils";
|
2019-08-31 13:27:12 +02:00
|
|
|
import {
|
|
|
|
parsePayUri,
|
|
|
|
parseWithdrawUri,
|
|
|
|
parseTipUri,
|
|
|
|
parseRefundUri,
|
|
|
|
} from "./taleruri";
|
2015-12-13 23:47:30 +01:00
|
|
|
|
2017-12-12 21:54:14 +01:00
|
|
|
interface SpeculativePayData {
|
|
|
|
payCoinInfo: PayCoinInfo;
|
|
|
|
exchangeUrl: string;
|
|
|
|
proposalId: number;
|
2018-01-17 03:49:54 +01:00
|
|
|
proposal: ProposalDownloadRecord;
|
2017-12-12 21:54:14 +01:00
|
|
|
}
|
|
|
|
|
2017-06-05 03:36:33 +02:00
|
|
|
/**
|
|
|
|
* Wallet protocol version spoken with the exchange
|
|
|
|
* and merchant.
|
|
|
|
*
|
|
|
|
* Uses libtool's current:revision:age versioning.
|
|
|
|
*/
|
2019-05-08 07:01:17 +02:00
|
|
|
export const WALLET_PROTOCOL_VERSION = "3:0:0";
|
2017-06-04 18:46:32 +02:00
|
|
|
|
2019-09-06 12:34:05 +02:00
|
|
|
const WALLET_CACHE_BREAKER_CLIENT_VERSION = "2";
|
2019-08-31 22:07:16 +02:00
|
|
|
|
2017-03-24 16:59:23 +01:00
|
|
|
const builtinCurrencies: CurrencyRecord[] = [
|
|
|
|
{
|
|
|
|
auditors: [
|
|
|
|
{
|
2017-06-04 19:41:43 +02:00
|
|
|
auditorPub: "BW9DC48PHQY4NH011SHHX36DZZ3Q22Y6X7FZ1VD1CMZ2PTFZ6PN0",
|
2017-04-28 23:28:27 +02:00
|
|
|
baseUrl: "https://auditor.demo.taler.net/",
|
2019-06-26 15:30:32 +02:00
|
|
|
expirationStamp: new Date(2027, 1).getTime(),
|
2017-03-24 16:59:23 +01:00
|
|
|
},
|
2017-04-12 17:47:14 +02:00
|
|
|
],
|
|
|
|
exchanges: [],
|
2017-05-28 01:10:54 +02:00
|
|
|
fractionalDigits: 2,
|
|
|
|
name: "KUDOS",
|
2017-03-24 16:59:23 +01:00
|
|
|
},
|
|
|
|
];
|
|
|
|
|
2016-11-16 01:59:39 +01:00
|
|
|
function isWithdrawableDenom(d: DenominationRecord) {
|
2019-06-26 15:30:32 +02:00
|
|
|
const nowSec = new Date().getTime() / 1000;
|
2017-05-28 01:10:54 +02:00
|
|
|
const stampWithdrawSec = getTalerStampSec(d.stampExpireWithdraw);
|
|
|
|
if (stampWithdrawSec === null) {
|
2017-04-20 03:09:25 +02:00
|
|
|
return false;
|
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
const stampStartSec = getTalerStampSec(d.stampStart);
|
|
|
|
if (stampStartSec === null) {
|
2017-04-20 03:09:25 +02:00
|
|
|
return false;
|
|
|
|
}
|
2016-02-10 02:03:31 +01:00
|
|
|
// Withdraw if still possible to withdraw within a minute
|
2019-06-26 15:30:32 +02:00
|
|
|
if (stampWithdrawSec + 60 > nowSec && nowSec >= stampStartSec) {
|
2016-02-10 02:03:31 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-08-30 17:08:54 +02:00
|
|
|
interface SelectPayCoinsResult {
|
|
|
|
cds: CoinWithDenom[];
|
|
|
|
totalFees: AmountJson;
|
|
|
|
}
|
|
|
|
|
2017-05-28 16:27:34 +02:00
|
|
|
/**
|
2017-08-30 17:08:54 +02:00
|
|
|
* 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.
|
2017-05-28 16:27:34 +02:00
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
export function getTotalRefreshCost(
|
|
|
|
denoms: DenominationRecord[],
|
|
|
|
refreshedDenom: DenominationRecord,
|
|
|
|
amountLeft: AmountJson,
|
|
|
|
): AmountJson {
|
|
|
|
const withdrawAmount = Amounts.sub(amountLeft, refreshedDenom.feeRefresh)
|
|
|
|
.amount;
|
2017-08-30 17:08:54 +02:00
|
|
|
const withdrawDenoms = getWithdrawDenomList(withdrawAmount, denoms);
|
2019-06-26 15:30:32 +02:00
|
|
|
const resultingAmount = Amounts.add(
|
|
|
|
Amounts.getZero(withdrawAmount.currency),
|
|
|
|
...withdrawDenoms.map(d => d.value),
|
|
|
|
).amount;
|
2017-08-30 17:08:54 +02:00
|
|
|
const totalCost = Amounts.sub(amountLeft, resultingAmount).amount;
|
2019-08-28 02:49:27 +02:00
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.log(
|
|
|
|
"total refresh cost for",
|
|
|
|
amountToPretty(amountLeft),
|
|
|
|
"is",
|
|
|
|
amountToPretty(totalCost),
|
|
|
|
);
|
2017-08-30 17:08:54 +02:00
|
|
|
return totalCost;
|
|
|
|
}
|
|
|
|
|
2017-05-28 16:27:34 +02:00
|
|
|
/**
|
|
|
|
* Select coins for a payment under the merchant's constraints.
|
2017-08-30 17:08:54 +02:00
|
|
|
*
|
|
|
|
* @param denoms all available denoms, used to compute refresh fees
|
2017-05-28 16:27:34 +02:00
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
export function selectPayCoins(
|
|
|
|
denoms: DenominationRecord[],
|
|
|
|
cds: CoinWithDenom[],
|
|
|
|
paymentAmount: AmountJson,
|
|
|
|
depositFeeLimit: AmountJson,
|
|
|
|
): SelectPayCoinsResult | undefined {
|
2017-05-28 01:10:54 +02:00
|
|
|
if (cds.length === 0) {
|
2016-11-14 03:01:42 +01:00
|
|
|
return undefined;
|
|
|
|
}
|
2017-08-30 17:08:54 +02:00
|
|
|
// Sort by ascending deposit fee and denomPub if deposit fee is the same
|
|
|
|
// (to guarantee deterministic results)
|
2019-06-26 15:30:32 +02:00
|
|
|
cds.sort(
|
|
|
|
(o1, o2) =>
|
|
|
|
Amounts.cmp(o1.denom.feeDeposit, o2.denom.feeDeposit) ||
|
|
|
|
strcmp(o1.denom.denomPub, o2.denom.denomPub),
|
|
|
|
);
|
2017-05-28 01:10:54 +02:00
|
|
|
const currency = cds[0].denom.value.currency;
|
|
|
|
const cdsResult: CoinWithDenom[] = [];
|
2017-08-30 17:08:54 +02:00
|
|
|
let accDepositFee: AmountJson = Amounts.getZero(currency);
|
2016-11-14 03:01:42 +01:00
|
|
|
let accAmount: AmountJson = Amounts.getZero(currency);
|
2019-06-26 15:30:32 +02:00
|
|
|
for (const { coin, denom } of cds) {
|
2016-11-18 00:09:43 +01:00
|
|
|
if (coin.suspended) {
|
|
|
|
continue;
|
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
if (coin.status !== CoinStatus.Fresh) {
|
2016-11-18 00:09:43 +01:00
|
|
|
continue;
|
|
|
|
}
|
2016-11-16 01:59:39 +01:00
|
|
|
if (Amounts.cmp(denom.feeDeposit, coin.currentAmount) >= 0) {
|
2016-11-14 03:01:42 +01:00
|
|
|
continue;
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
cdsResult.push({ coin, denom });
|
2017-08-30 17:08:54 +02:00
|
|
|
accDepositFee = Amounts.add(denom.feeDeposit, accDepositFee).amount;
|
2019-06-26 15:30:32 +02:00
|
|
|
let leftAmount = Amounts.sub(
|
|
|
|
coin.currentAmount,
|
|
|
|
Amounts.sub(paymentAmount, accAmount).amount,
|
|
|
|
).amount;
|
2016-11-14 03:01:42 +01:00
|
|
|
accAmount = Amounts.add(coin.currentAmount, accAmount).amount;
|
2017-08-30 17:08:54 +02:00
|
|
|
const coversAmount = Amounts.cmp(accAmount, paymentAmount) >= 0;
|
2019-06-26 15:30:32 +02:00
|
|
|
const coversAmountWithFee =
|
|
|
|
Amounts.cmp(
|
|
|
|
accAmount,
|
|
|
|
Amounts.add(paymentAmount, denom.feeDeposit).amount,
|
|
|
|
) >= 0;
|
2017-08-30 17:08:54 +02:00
|
|
|
const isBelowFee = Amounts.cmp(accDepositFee, depositFeeLimit) <= 0;
|
2017-08-14 04:16:12 +02:00
|
|
|
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.log("candidate coin selection", {
|
|
|
|
coversAmount,
|
|
|
|
isBelowFee,
|
|
|
|
accDepositFee,
|
|
|
|
accAmount,
|
|
|
|
paymentAmount,
|
|
|
|
});
|
2017-08-27 05:57:39 +02:00
|
|
|
|
2016-11-14 03:01:42 +01:00
|
|
|
if ((coversAmount && isBelowFee) || coversAmountWithFee) {
|
2019-06-26 15:30:32 +02:00
|
|
|
const depositFeeToCover = Amounts.sub(accDepositFee, depositFeeLimit)
|
|
|
|
.amount;
|
2017-08-30 17:08:54 +02:00
|
|
|
leftAmount = Amounts.sub(leftAmount, depositFeeToCover).amount;
|
2019-08-28 02:49:27 +02:00
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.log("deposit fee to cover", amountToPretty(depositFeeToCover));
|
2017-08-30 17:08:54 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
totalFees = Amounts.add(
|
|
|
|
totalFees,
|
|
|
|
getTotalRefreshCost(denoms, denom, leftAmount),
|
|
|
|
).amount;
|
2017-08-30 17:08:54 +02:00
|
|
|
return { cds: cdsResult, totalFees };
|
2016-11-14 03:01:42 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return undefined;
|
|
|
|
}
|
|
|
|
|
2016-02-11 18:17:02 +01:00
|
|
|
/**
|
|
|
|
* Get a list of denominations (with repetitions possible)
|
|
|
|
* whose total value is as close as possible to the available
|
|
|
|
* amount, but never larger.
|
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
function getWithdrawDenomList(
|
|
|
|
amountAvailable: AmountJson,
|
|
|
|
denoms: DenominationRecord[],
|
|
|
|
): DenominationRecord[] {
|
2016-02-22 23:13:28 +01:00
|
|
|
let remaining = Amounts.copy(amountAvailable);
|
2016-11-16 01:59:39 +01:00
|
|
|
const ds: DenominationRecord[] = [];
|
2016-02-11 18:17:02 +01:00
|
|
|
|
|
|
|
denoms = denoms.filter(isWithdrawableDenom);
|
2016-02-22 23:13:28 +01:00
|
|
|
denoms.sort((d1, d2) => Amounts.cmp(d2.value, d1.value));
|
|
|
|
|
2016-02-11 18:17:02 +01:00
|
|
|
// 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;
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const d of denoms) {
|
|
|
|
const cost = Amounts.add(d.value, d.feeWithdraw).amount;
|
2016-02-22 23:13:28 +01:00
|
|
|
if (Amounts.cmp(remaining, cost) < 0) {
|
2016-02-11 18:17:02 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
found = true;
|
2016-02-22 23:13:28 +01:00
|
|
|
remaining = Amounts.sub(remaining, cost).amount;
|
2016-02-11 18:17:02 +01:00
|
|
|
ds.push(d);
|
2016-02-22 23:13:28 +01:00
|
|
|
break;
|
2016-02-11 18:17:02 +01:00
|
|
|
}
|
|
|
|
if (!found) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ds;
|
|
|
|
}
|
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
interface CoinsForPaymentArgs {
|
|
|
|
allowedAuditors: Auditor[];
|
|
|
|
allowedExchanges: ExchangeHandle[];
|
|
|
|
depositFeeLimit: AmountJson;
|
|
|
|
paymentAmount: AmountJson;
|
|
|
|
wireFeeAmortization: number;
|
|
|
|
wireFeeLimit: AmountJson;
|
|
|
|
wireFeeTime: number;
|
|
|
|
wireMethod: string;
|
2016-10-18 01:16:31 +02:00
|
|
|
}
|
|
|
|
|
2017-05-28 16:27:34 +02:00
|
|
|
/**
|
|
|
|
* The platform-independent wallet implementation.
|
|
|
|
*/
|
2016-01-10 20:07:42 +01:00
|
|
|
export class Wallet {
|
2017-06-05 02:00:03 +02:00
|
|
|
/**
|
|
|
|
* IndexedDB database used by the wallet.
|
|
|
|
*/
|
|
|
|
db: IDBDatabase;
|
2019-08-18 23:06:27 +02:00
|
|
|
static enableTracing = false;
|
2016-01-06 15:39:22 +01:00
|
|
|
private http: HttpRequestLibrary;
|
|
|
|
private badge: Badge;
|
2016-02-18 23:41:29 +01:00
|
|
|
private notifier: Notifier;
|
2017-05-28 16:27:34 +02:00
|
|
|
private cryptoApi: CryptoApi;
|
2016-11-17 01:23:53 +01:00
|
|
|
private processPreCoinConcurrent = 0;
|
2019-06-26 15:30:32 +02:00
|
|
|
private processPreCoinThrottle: { [url: string]: number } = {};
|
2017-06-05 02:00:03 +02:00
|
|
|
private timerGroup: TimerGroup;
|
2017-12-12 21:54:14 +01:00
|
|
|
private speculativePayData: SpeculativePayData | undefined;
|
2018-01-18 02:50:18 +01:00
|
|
|
private cachedNextUrl: { [fulfillmentUrl: string]: NextUrlResult } = {};
|
2019-08-30 17:27:59 +02:00
|
|
|
private activeTipOperations: { [s: string]: Promise<void> } = {};
|
2019-08-01 23:21:15 +02:00
|
|
|
private activeProcessReserveOperations: {
|
|
|
|
[reservePub: string]: Promise<void>;
|
|
|
|
} = {};
|
|
|
|
private activeProcessPreCoinOperations: {
|
|
|
|
[preCoinPub: string]: Promise<void>;
|
|
|
|
} = {};
|
2019-09-04 15:28:19 +02:00
|
|
|
private activeRefreshOperations: {
|
|
|
|
[coinPub: string]: Promise<void>;
|
|
|
|
} = {};
|
2016-11-17 01:23:53 +01:00
|
|
|
|
2016-05-24 02:05:19 +02:00
|
|
|
/**
|
|
|
|
* Set of identifiers for running operations.
|
|
|
|
*/
|
|
|
|
private runningOperations: Set<string> = new Set();
|
2016-02-11 18:17:02 +01:00
|
|
|
|
2016-10-13 02:23:24 +02:00
|
|
|
q(): QueryRoot {
|
|
|
|
return new QueryRoot(this.db);
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
constructor(
|
|
|
|
db: IDBDatabase,
|
|
|
|
http: HttpRequestLibrary,
|
|
|
|
badge: Badge,
|
|
|
|
notifier: Notifier,
|
2019-08-15 19:10:23 +02:00
|
|
|
cryptoWorkerFactory: CryptoWorkerFactory,
|
2019-06-26 15:30:32 +02:00
|
|
|
) {
|
2016-01-06 15:39:22 +01:00
|
|
|
this.db = db;
|
|
|
|
this.http = http;
|
|
|
|
this.badge = badge;
|
2016-02-18 23:41:29 +01:00
|
|
|
this.notifier = notifier;
|
2019-08-15 19:10:23 +02:00
|
|
|
this.cryptoApi = new CryptoApi(cryptoWorkerFactory);
|
2017-06-05 02:00:03 +02:00
|
|
|
this.timerGroup = new TimerGroup();
|
|
|
|
|
2017-12-10 21:34:56 +01:00
|
|
|
const init = async () => {
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.fillDefaults().catch(e => console.log(e));
|
|
|
|
await this.collectGarbage().catch(e => console.log(e));
|
2017-12-10 21:34:56 +01:00
|
|
|
this.updateExchanges();
|
|
|
|
this.resumePendingFromDb();
|
|
|
|
this.timerGroup.every(1000 * 60 * 15, () => this.updateExchanges());
|
|
|
|
};
|
|
|
|
|
|
|
|
init();
|
2016-05-24 01:18:23 +02:00
|
|
|
}
|
|
|
|
|
2017-03-24 16:59:23 +01:00
|
|
|
private async fillDefaults() {
|
2019-08-24 18:42:00 +02:00
|
|
|
const onTrue = (r: QueryRoot) => {};
|
2017-05-28 01:10:54 +02:00
|
|
|
const onFalse = (r: QueryRoot) => {
|
2019-08-18 23:06:27 +02:00
|
|
|
Wallet.enableTracing && console.log("applying defaults");
|
2019-06-26 15:30:32 +02:00
|
|
|
r.put(Stores.config, { key: "currencyDefaultsApplied", value: true })
|
2017-03-24 16:59:23 +01:00
|
|
|
.putAll(Stores.currencies, builtinCurrencies)
|
|
|
|
.finish();
|
|
|
|
};
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.iter(Stores.config)
|
|
|
|
.filter(x => x.key === "currencyDefaultsApplied")
|
|
|
|
.first()
|
|
|
|
.cond(x => x && x.value, onTrue, onFalse);
|
2017-03-24 16:59:23 +01:00
|
|
|
}
|
|
|
|
|
2016-05-24 02:05:19 +02:00
|
|
|
private startOperation(operationId: string) {
|
|
|
|
this.runningOperations.add(operationId);
|
|
|
|
this.badge.startBusy();
|
|
|
|
}
|
|
|
|
|
|
|
|
private stopOperation(operationId: string) {
|
|
|
|
this.runningOperations.delete(operationId);
|
2017-05-28 01:10:54 +02:00
|
|
|
if (this.runningOperations.size === 0) {
|
2016-05-24 02:05:19 +02:00
|
|
|
this.badge.stopBusy();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-20 01:37:00 +02:00
|
|
|
async updateExchanges(): Promise<void> {
|
2017-05-28 01:10:54 +02:00
|
|
|
const exchangesUrls = await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter(Stores.exchanges)
|
|
|
|
.map(e => e.baseUrl)
|
|
|
|
.toArray();
|
2016-10-19 23:55:58 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const url of exchangesUrls) {
|
2019-06-26 15:30:32 +02:00
|
|
|
this.updateExchangeFromUrl(url).catch(e => {
|
|
|
|
console.error("updating exchange failed", e);
|
|
|
|
});
|
2016-10-19 23:55:58 +02:00
|
|
|
}
|
2016-05-24 17:30:27 +02:00
|
|
|
}
|
|
|
|
|
2016-05-24 01:18:23 +02:00
|
|
|
/**
|
|
|
|
* Resume various pending operations that are pending
|
|
|
|
* by looking at the database.
|
|
|
|
*/
|
|
|
|
private resumePendingFromDb(): void {
|
2019-08-24 18:42:00 +02:00
|
|
|
Wallet.enableTracing && console.log("resuming pending operations from db");
|
2016-05-24 01:18:23 +02:00
|
|
|
|
2016-10-13 02:23:24 +02:00
|
|
|
this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter(Stores.reserves)
|
|
|
|
.forEach(reserve => {
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.log("resuming reserve", reserve.reserve_pub);
|
2019-08-01 23:21:15 +02:00
|
|
|
this.processReserve(reserve.reserve_pub);
|
2019-06-26 15:30:32 +02:00
|
|
|
});
|
2016-10-13 02:23:24 +02:00
|
|
|
|
|
|
|
this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter(Stores.precoins)
|
|
|
|
.forEach(preCoin => {
|
2019-08-24 18:42:00 +02:00
|
|
|
Wallet.enableTracing && console.log("resuming precoin");
|
2019-08-01 23:21:15 +02:00
|
|
|
this.processPreCoin(preCoin.coinPub);
|
2019-06-26 15:30:32 +02:00
|
|
|
});
|
2016-10-17 23:49:04 +02:00
|
|
|
|
|
|
|
this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter(Stores.refresh)
|
|
|
|
.forEach((r: RefreshSessionRecord) => {
|
|
|
|
this.continueRefreshSession(r);
|
|
|
|
});
|
2016-10-17 23:49:04 +02:00
|
|
|
|
2017-08-14 04:16:12 +02:00
|
|
|
this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter(Stores.coinsReturns)
|
|
|
|
.forEach((r: CoinsReturnRecord) => {
|
|
|
|
this.depositReturnedCoins(r);
|
|
|
|
});
|
2017-08-14 04:16:12 +02:00
|
|
|
|
2016-10-17 23:49:04 +02:00
|
|
|
// FIXME: optimize via index
|
|
|
|
this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter(Stores.coins)
|
|
|
|
.forEach((c: CoinRecord) => {
|
|
|
|
if (c.status === CoinStatus.Dirty) {
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.log("resuming pending refresh for coin", c);
|
2019-06-26 15:30:32 +02:00
|
|
|
this.refresh(c.coinPub);
|
|
|
|
}
|
|
|
|
});
|
2016-01-05 14:20:13 +01:00
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
private async getCoinsForReturn(
|
|
|
|
exchangeBaseUrl: string,
|
|
|
|
amount: AmountJson,
|
|
|
|
): Promise<CoinWithDenom[] | undefined> {
|
2017-08-14 04:16:12 +02:00
|
|
|
const exchange = await this.q().get(Stores.exchanges, exchangeBaseUrl);
|
|
|
|
if (!exchange) {
|
|
|
|
throw Error(`Exchange ${exchangeBaseUrl} not known to the wallet`);
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const coins: CoinRecord[] = await this.q()
|
|
|
|
.iterIndex(Stores.coins.exchangeBaseUrlIndex, exchange.baseUrl)
|
|
|
|
.toArray();
|
2017-08-14 04:16:12 +02:00
|
|
|
|
|
|
|
if (!coins || !coins.length) {
|
|
|
|
return [];
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const denoms = await this.q()
|
|
|
|
.iterIndex(Stores.denominations.exchangeBaseUrlIndex, exchange.baseUrl)
|
|
|
|
.toArray();
|
2017-08-30 17:08:54 +02:00
|
|
|
|
2017-08-14 04:16:12 +02:00
|
|
|
// Denomination of the first coin, we assume that all other
|
|
|
|
// coins have the same currency
|
2019-06-26 15:30:32 +02:00
|
|
|
const firstDenom = await this.q().get(Stores.denominations, [
|
|
|
|
exchange.baseUrl,
|
|
|
|
coins[0].denomPub,
|
|
|
|
]);
|
2017-08-14 04:16:12 +02:00
|
|
|
if (!firstDenom) {
|
|
|
|
throw Error("db inconsistent");
|
|
|
|
}
|
|
|
|
const currency = firstDenom.value.currency;
|
|
|
|
|
|
|
|
const cds: CoinWithDenom[] = [];
|
|
|
|
for (const coin of coins) {
|
2019-06-26 15:30:32 +02:00
|
|
|
const denom = await this.q().get(Stores.denominations, [
|
|
|
|
exchange.baseUrl,
|
|
|
|
coin.denomPub,
|
|
|
|
]);
|
2017-08-14 04:16:12 +02:00
|
|
|
if (!denom) {
|
|
|
|
throw Error("db inconsistent");
|
|
|
|
}
|
|
|
|
if (denom.value.currency !== currency) {
|
2019-06-26 15:30:32 +02:00
|
|
|
console.warn(
|
2019-08-26 01:39:13 +02:00
|
|
|
`same pubkey for different currencies at exchange ${exchange.baseUrl}`,
|
2019-06-26 15:30:32 +02:00
|
|
|
);
|
2017-08-14 04:16:12 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (coin.suspended) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (coin.status !== CoinStatus.Fresh) {
|
|
|
|
continue;
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
cds.push({ coin, denom });
|
2017-08-14 04:16:12 +02:00
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
console.log("coin return: selecting from possible coins", { cds, amount });
|
2017-08-27 05:57:39 +02:00
|
|
|
|
2017-08-30 17:08:54 +02:00
|
|
|
const res = selectPayCoins(denoms, cds, amount, amount);
|
|
|
|
if (res) {
|
|
|
|
return res.cds;
|
|
|
|
}
|
2017-10-15 19:28:35 +02:00
|
|
|
return undefined;
|
2017-08-14 04:16:12 +02:00
|
|
|
}
|
|
|
|
|
2016-01-06 15:39:22 +01:00
|
|
|
/**
|
2019-08-15 23:34:08 +02:00
|
|
|
* Get exchanges and associated coins that are still spendable, but only
|
|
|
|
* if the sum the coins' remaining value covers the payment amount and fees.
|
2016-01-06 15:39:22 +01:00
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
private async getCoinsForPayment(
|
|
|
|
args: CoinsForPaymentArgs,
|
|
|
|
): Promise<CoinSelectionResult | undefined> {
|
2017-05-28 01:10:54 +02:00
|
|
|
const {
|
|
|
|
allowedAuditors,
|
|
|
|
allowedExchanges,
|
|
|
|
depositFeeLimit,
|
|
|
|
paymentAmount,
|
|
|
|
wireFeeAmortization,
|
|
|
|
wireFeeLimit,
|
|
|
|
wireFeeTime,
|
|
|
|
wireMethod,
|
|
|
|
} = args;
|
|
|
|
|
|
|
|
let remainingAmount = paymentAmount;
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const exchanges = await this.q()
|
|
|
|
.iter(Stores.exchanges)
|
|
|
|
.toArray();
|
2017-05-28 01:10:54 +02:00
|
|
|
|
|
|
|
for (const exchange of exchanges) {
|
2017-04-26 14:11:35 +02:00
|
|
|
let isOkay: boolean = false;
|
|
|
|
|
|
|
|
// is the exchange explicitly allowed?
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const allowedExchange of allowedExchanges) {
|
|
|
|
if (allowedExchange.master_pub === exchange.masterPublicKey) {
|
2017-04-26 14:11:35 +02:00
|
|
|
isOkay = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// is the exchange allowed because of one of its auditors?
|
|
|
|
if (!isOkay) {
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const allowedAuditor of allowedAuditors) {
|
|
|
|
for (const auditor of exchange.auditors) {
|
|
|
|
if (auditor.auditor_pub === allowedAuditor.auditor_pub) {
|
2017-04-26 14:11:35 +02:00
|
|
|
isOkay = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (isOkay) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!isOkay) {
|
2016-11-14 02:52:29 +01:00
|
|
|
continue;
|
2016-05-24 17:30:27 +02:00
|
|
|
}
|
2017-04-26 14:11:35 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const coins: CoinRecord[] = await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iterIndex(Stores.coins.exchangeBaseUrlIndex, exchange.baseUrl)
|
|
|
|
.toArray();
|
2019-08-15 23:34:08 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const denoms = await this.q()
|
|
|
|
.iterIndex(Stores.denominations.exchangeBaseUrlIndex, exchange.baseUrl)
|
|
|
|
.toArray();
|
2017-05-28 01:10:54 +02:00
|
|
|
if (!coins || coins.length === 0) {
|
2016-11-14 02:52:29 +01:00
|
|
|
continue;
|
2016-01-06 15:39:22 +01:00
|
|
|
}
|
2017-08-14 04:16:12 +02:00
|
|
|
|
2016-11-14 02:52:29 +01:00
|
|
|
// Denomination of the first coin, we assume that all other
|
|
|
|
// coins have the same currency
|
2019-06-26 15:30:32 +02:00
|
|
|
const firstDenom = await this.q().get(Stores.denominations, [
|
|
|
|
exchange.baseUrl,
|
|
|
|
coins[0].denomPub,
|
|
|
|
]);
|
2016-11-14 02:52:29 +01:00
|
|
|
if (!firstDenom) {
|
|
|
|
throw Error("db inconsistent");
|
2016-02-19 13:03:45 +01:00
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
const currency = firstDenom.value.currency;
|
|
|
|
const cds: CoinWithDenom[] = [];
|
|
|
|
for (const coin of coins) {
|
2019-06-26 15:30:32 +02:00
|
|
|
const denom = await this.q().get(Stores.denominations, [
|
|
|
|
exchange.baseUrl,
|
|
|
|
coin.denomPub,
|
|
|
|
]);
|
2016-11-14 02:52:29 +01:00
|
|
|
if (!denom) {
|
|
|
|
throw Error("db inconsistent");
|
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
if (denom.value.currency !== currency) {
|
2019-06-26 15:30:32 +02:00
|
|
|
console.warn(
|
2019-08-26 01:39:13 +02:00
|
|
|
`same pubkey for different currencies at exchange ${exchange.baseUrl}`,
|
2019-06-26 15:30:32 +02:00
|
|
|
);
|
2016-11-14 02:52:29 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (coin.suspended) {
|
|
|
|
continue;
|
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
if (coin.status !== CoinStatus.Fresh) {
|
2016-11-18 00:09:43 +01:00
|
|
|
continue;
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
cds.push({ coin, denom });
|
2016-01-06 15:39:22 +01:00
|
|
|
}
|
2016-03-05 01:36:38 +01:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const fees = await this.q().get(
|
|
|
|
Stores.exchangeWireFees,
|
|
|
|
exchange.baseUrl,
|
|
|
|
);
|
2017-04-27 04:06:48 +02:00
|
|
|
if (!fees) {
|
|
|
|
console.error("no fees found for exchange", exchange);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-08-30 17:08:54 +02:00
|
|
|
let totalFees = Amounts.getZero(currency);
|
2019-06-26 15:30:32 +02:00
|
|
|
let wireFee: AmountJson | undefined;
|
|
|
|
for (const fee of fees.feesForType[wireMethod] || []) {
|
2018-01-17 05:33:06 +01:00
|
|
|
if (fee.startStamp <= wireFeeTime && fee.endStamp >= wireFeeTime) {
|
2017-04-27 04:06:48 +02:00
|
|
|
wireFee = fee.wireFee;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wireFee) {
|
2017-05-28 01:10:54 +02:00
|
|
|
const amortizedWireFee = Amounts.divide(wireFee, wireFeeAmortization);
|
2017-04-27 04:06:48 +02:00
|
|
|
if (Amounts.cmp(wireFeeLimit, amortizedWireFee) < 0) {
|
2017-08-30 17:08:54 +02:00
|
|
|
totalFees = Amounts.add(amortizedWireFee, totalFees).amount;
|
2019-06-26 15:30:32 +02:00
|
|
|
remainingAmount = Amounts.add(amortizedWireFee, remainingAmount)
|
|
|
|
.amount;
|
2017-04-27 04:06:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-30 17:08:54 +02:00
|
|
|
const res = selectPayCoins(denoms, cds, remainingAmount, depositFeeLimit);
|
2019-08-15 23:34:08 +02:00
|
|
|
|
2016-11-14 03:01:42 +01:00
|
|
|
if (res) {
|
2017-08-30 17:08:54 +02:00
|
|
|
totalFees = Amounts.add(totalFees, res.totalFees).amount;
|
2016-11-14 03:01:42 +01:00
|
|
|
return {
|
2017-08-30 17:08:54 +02:00
|
|
|
cds: res.cds,
|
2017-05-28 01:10:54 +02:00
|
|
|
exchangeUrl: exchange.baseUrl,
|
2018-01-17 05:33:06 +01:00
|
|
|
totalAmount: remainingAmount,
|
2017-08-30 17:08:54 +02:00
|
|
|
totalFees,
|
2017-05-28 01:10:54 +02:00
|
|
|
};
|
2016-03-05 01:36:38 +01:00
|
|
|
}
|
2016-11-14 02:52:29 +01:00
|
|
|
}
|
|
|
|
return undefined;
|
2016-01-06 15:39:22 +01:00
|
|
|
}
|
2015-12-13 23:47:30 +01:00
|
|
|
|
2016-02-10 02:03:31 +01:00
|
|
|
/**
|
|
|
|
* Record all information that is necessary to
|
2017-06-01 18:46:07 +02:00
|
|
|
* pay for a proposal in the wallet's database.
|
2016-02-10 02:03:31 +01:00
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
private async recordConfirmPay(
|
|
|
|
proposal: ProposalDownloadRecord,
|
|
|
|
payCoinInfo: PayCoinInfo,
|
|
|
|
chosenExchange: string,
|
|
|
|
): Promise<PurchaseRecord> {
|
2017-05-28 01:10:54 +02:00
|
|
|
const payReq: PayReq = {
|
2017-12-12 21:54:14 +01:00
|
|
|
coins: payCoinInfo.sigs,
|
2017-05-31 16:04:14 +02:00
|
|
|
merchant_pub: proposal.contractTerms.merchant_pub,
|
2018-01-04 13:22:23 +01:00
|
|
|
mode: "pay",
|
2017-05-31 16:04:14 +02:00
|
|
|
order_id: proposal.contractTerms.order_id,
|
2016-10-17 15:58:36 +02:00
|
|
|
};
|
2017-08-27 03:56:19 +02:00
|
|
|
const t: PurchaseRecord = {
|
2018-01-29 16:41:17 +01:00
|
|
|
abortDone: false,
|
|
|
|
abortRequested: false,
|
2017-06-01 18:46:07 +02:00
|
|
|
contractTerms: proposal.contractTerms,
|
|
|
|
contractTermsHash: proposal.contractTermsHash,
|
2016-10-19 22:49:03 +02:00
|
|
|
finished: false,
|
2018-01-18 02:50:18 +01:00
|
|
|
lastSessionId: undefined,
|
2017-05-31 16:04:14 +02:00
|
|
|
merchantSig: proposal.merchantSig,
|
2017-05-28 01:10:54 +02:00
|
|
|
payReq,
|
2017-08-27 03:56:19 +02:00
|
|
|
refundsDone: {},
|
|
|
|
refundsPending: {},
|
2019-06-26 15:30:32 +02:00
|
|
|
timestamp: new Date().getTime(),
|
2017-10-15 18:30:02 +02:00
|
|
|
timestamp_refund: 0,
|
2016-01-24 02:29:13 +01:00
|
|
|
};
|
|
|
|
|
2016-10-13 02:23:24 +02:00
|
|
|
await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.put(Stores.purchases, t)
|
|
|
|
.putAll(Stores.coins, payCoinInfo.updatedCoins)
|
|
|
|
.finish();
|
2017-12-12 16:39:55 +01:00
|
|
|
this.badge.showNotification();
|
2016-09-28 18:00:13 +02:00
|
|
|
this.notifier.notify();
|
2018-01-17 03:49:54 +01:00
|
|
|
return t;
|
2016-01-06 15:39:22 +01:00
|
|
|
}
|
2015-12-14 16:54:47 +01:00
|
|
|
|
2019-08-29 23:12:55 +02:00
|
|
|
getNextUrl(contractTerms: ContractTerms): string {
|
|
|
|
const fu = new URI(contractTerms.fulfillment_url);
|
|
|
|
fu.addSearch("order_id", contractTerms.order_id);
|
|
|
|
return fu.href();
|
|
|
|
}
|
|
|
|
|
2019-09-06 09:48:00 +02:00
|
|
|
/**
|
|
|
|
* Check if a payment for the given taler://pay/ URI is possible.
|
2019-09-06 11:06:28 +02:00
|
|
|
*
|
2019-09-06 09:48:00 +02:00
|
|
|
* If the payment is possible, the signature are already generated but not
|
|
|
|
* yet send to the merchant.
|
|
|
|
*/
|
|
|
|
async preparePay(talerPayUri: string): Promise<PreparePayResult> {
|
|
|
|
const uriResult = parsePayUri(talerPayUri);
|
2019-08-28 02:49:27 +02:00
|
|
|
|
|
|
|
if (!uriResult) {
|
|
|
|
return {
|
|
|
|
status: "error",
|
|
|
|
error: "URI not supported",
|
|
|
|
};
|
2019-08-20 17:58:01 +02:00
|
|
|
}
|
2019-08-28 02:49:27 +02:00
|
|
|
|
2019-08-20 17:58:01 +02:00
|
|
|
let proposalId: number;
|
|
|
|
try {
|
2019-08-28 02:49:27 +02:00
|
|
|
proposalId = await this.downloadProposal(
|
|
|
|
uriResult.downloadUrl,
|
|
|
|
uriResult.sessionId,
|
|
|
|
);
|
2019-08-20 17:58:01 +02:00
|
|
|
} catch (e) {
|
|
|
|
return {
|
|
|
|
status: "error",
|
|
|
|
error: e.toString(),
|
2019-08-24 18:42:00 +02:00
|
|
|
};
|
2019-08-20 17:58:01 +02:00
|
|
|
}
|
|
|
|
const proposal = await this.getProposal(proposalId);
|
|
|
|
if (!proposal) {
|
|
|
|
throw Error("could not get proposal");
|
|
|
|
}
|
2019-08-28 02:49:27 +02:00
|
|
|
|
|
|
|
console.log("proposal", proposal);
|
|
|
|
|
2019-09-06 11:06:28 +02:00
|
|
|
const differentPurchase = await this.q().getIndexed(
|
|
|
|
Stores.purchases.fulfillmentUrlIndex,
|
|
|
|
proposal.contractTerms.fulfillment_url,
|
|
|
|
);
|
|
|
|
|
|
|
|
if (differentPurchase) {
|
|
|
|
// 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 {
|
2019-09-06 11:45:53 +02:00
|
|
|
if (uriResult.sessionId) {
|
2019-09-06 12:34:05 +02:00
|
|
|
await this.submitPay(
|
|
|
|
differentPurchase.contractTermsHash,
|
|
|
|
uriResult.sessionId,
|
|
|
|
);
|
2019-09-06 11:45:53 +02:00
|
|
|
}
|
2019-09-06 11:06:28 +02:00
|
|
|
return {
|
|
|
|
status: "paid",
|
|
|
|
contractTerms: differentPurchase.contractTerms,
|
|
|
|
nextUrl: this.getNextUrl(differentPurchase.contractTerms),
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-06 09:48:00 +02:00
|
|
|
// First check if we already payed for it.
|
|
|
|
const purchase = await this.q().get(
|
|
|
|
Stores.purchases,
|
|
|
|
proposal.contractTermsHash,
|
|
|
|
);
|
|
|
|
|
|
|
|
if (!purchase) {
|
|
|
|
const paymentAmount = Amounts.parseOrThrow(proposal.contractTerms.amount);
|
|
|
|
let wireFeeLimit;
|
|
|
|
if (proposal.contractTerms.max_wire_fee) {
|
2019-09-06 11:06:28 +02:00
|
|
|
wireFeeLimit = Amounts.parseOrThrow(
|
|
|
|
proposal.contractTerms.max_wire_fee,
|
|
|
|
);
|
2019-09-06 09:48:00 +02:00
|
|
|
} 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,
|
|
|
|
wireFeeTime: getTalerStampSec(proposal.contractTerms.timestamp) || 0,
|
|
|
|
wireMethod: proposal.contractTerms.wire_method,
|
|
|
|
});
|
|
|
|
|
|
|
|
if (!res) {
|
|
|
|
console.log("not confirming payment, insufficient coins");
|
2019-08-28 02:49:27 +02:00
|
|
|
return {
|
2019-09-06 09:48:00 +02:00
|
|
|
status: "insufficient-balance",
|
|
|
|
contractTerms: proposal.contractTerms,
|
|
|
|
proposalId: proposal.id!,
|
2019-08-28 02:49:27 +02:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-09-06 09:48:00 +02:00
|
|
|
// Only create speculative signature if we don't already have one for this proposal
|
|
|
|
if (
|
|
|
|
!this.speculativePayData ||
|
|
|
|
(this.speculativePayData &&
|
|
|
|
this.speculativePayData.proposalId !== proposalId)
|
|
|
|
) {
|
|
|
|
const { exchangeUrl, cds, totalAmount } = res;
|
|
|
|
const payCoinInfo = await this.cryptoApi.signDeposit(
|
|
|
|
proposal.contractTerms,
|
|
|
|
cds,
|
|
|
|
totalAmount,
|
|
|
|
);
|
|
|
|
this.speculativePayData = {
|
|
|
|
exchangeUrl,
|
|
|
|
payCoinInfo,
|
|
|
|
proposal,
|
|
|
|
proposalId,
|
|
|
|
};
|
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.log("created speculative pay data for payment");
|
|
|
|
}
|
|
|
|
|
2019-08-20 17:58:01 +02:00
|
|
|
return {
|
|
|
|
status: "payment-possible",
|
|
|
|
contractTerms: proposal.contractTerms,
|
|
|
|
proposalId: proposal.id!,
|
2019-09-06 09:48:00 +02:00
|
|
|
totalFees: res.totalFees,
|
2019-08-20 17:58:01 +02:00
|
|
|
};
|
|
|
|
}
|
2019-09-06 09:48:00 +02:00
|
|
|
|
|
|
|
if (uriResult.sessionId) {
|
2019-09-06 11:06:28 +02:00
|
|
|
await this.submitPay(purchase.contractTermsHash, uriResult.sessionId);
|
2019-09-06 09:48:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return {
|
|
|
|
status: "paid",
|
|
|
|
contractTerms: proposal.contractTerms,
|
|
|
|
nextUrl: this.getNextUrl(purchase.contractTerms),
|
|
|
|
};
|
2019-08-20 17:58:01 +02:00
|
|
|
}
|
|
|
|
|
2017-05-31 16:04:14 +02:00
|
|
|
/**
|
2018-01-17 03:49:54 +01:00
|
|
|
* Download a proposal and store it in the database.
|
|
|
|
* Returns an id for it to retrieve it later.
|
2019-08-24 18:42:00 +02:00
|
|
|
*
|
|
|
|
* @param sessionId Current session ID, if the proposal is being
|
|
|
|
* downloaded in the context of a session ID.
|
2017-05-31 16:04:14 +02:00
|
|
|
*/
|
2019-08-24 18:42:00 +02:00
|
|
|
async downloadProposal(url: string, sessionId?: string): Promise<number> {
|
2019-06-26 15:30:32 +02:00
|
|
|
const oldProposal = await this.q().getIndexed(
|
|
|
|
Stores.proposals.urlIndex,
|
|
|
|
url,
|
|
|
|
);
|
2018-01-18 01:37:30 +01:00
|
|
|
if (oldProposal) {
|
|
|
|
return oldProposal.id!;
|
|
|
|
}
|
|
|
|
|
2018-01-17 03:49:54 +01:00
|
|
|
const { priv, pub } = await this.cryptoApi.createEddsaKeypair();
|
|
|
|
const parsed_url = new URI(url);
|
2018-01-18 01:37:30 +01:00
|
|
|
const urlWithNonce = parsed_url.setQuery({ nonce: pub }).href();
|
|
|
|
console.log("downloading contract from '" + urlWithNonce + "'");
|
2018-01-17 03:49:54 +01:00
|
|
|
let resp;
|
|
|
|
try {
|
2019-08-22 23:36:36 +02:00
|
|
|
resp = await this.http.get(urlWithNonce);
|
2018-01-17 03:49:54 +01:00
|
|
|
} catch (e) {
|
|
|
|
console.log("contract download failed", e);
|
|
|
|
throw e;
|
|
|
|
}
|
|
|
|
|
2019-08-22 23:36:36 +02:00
|
|
|
const proposal = Proposal.checked(resp.responseJson);
|
2018-01-17 03:49:54 +01:00
|
|
|
|
|
|
|
const contractTermsHash = await this.hashContract(proposal.contract_terms);
|
|
|
|
|
|
|
|
const proposalRecord: ProposalDownloadRecord = {
|
|
|
|
contractTerms: proposal.contract_terms,
|
|
|
|
contractTermsHash,
|
|
|
|
merchantSig: proposal.sig,
|
|
|
|
noncePriv: priv,
|
2019-06-26 15:30:32 +02:00
|
|
|
timestamp: new Date().getTime(),
|
2018-01-17 03:49:54 +01:00
|
|
|
url,
|
2019-08-24 18:42:00 +02:00
|
|
|
downloadSessionId: sessionId,
|
2018-01-17 03:49:54 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
const id = await this.q().putWithResult(Stores.proposals, proposalRecord);
|
2016-11-13 10:17:39 +01:00
|
|
|
this.notifier.notify();
|
|
|
|
if (typeof id !== "number") {
|
|
|
|
throw Error("db schema wrong");
|
|
|
|
}
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2018-01-29 16:41:17 +01:00
|
|
|
async refundFailedPay(proposalId: number) {
|
|
|
|
console.log(`refunding failed payment with proposal id ${proposalId}`);
|
2019-06-26 15:30:32 +02:00
|
|
|
const proposal: ProposalDownloadRecord | undefined = await this.q().get(
|
|
|
|
Stores.proposals,
|
|
|
|
proposalId,
|
|
|
|
);
|
2018-01-29 16:41:17 +01:00
|
|
|
|
|
|
|
if (!proposal) {
|
|
|
|
throw Error(`proposal with id ${proposalId} not found`);
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const purchase = await this.q().get(
|
|
|
|
Stores.purchases,
|
|
|
|
proposal.contractTermsHash,
|
|
|
|
);
|
2018-01-29 16:41:17 +01:00
|
|
|
if (!purchase) {
|
|
|
|
throw Error("purchase not found for proposal");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (purchase.finished) {
|
|
|
|
throw Error("can't auto-refund finished purchase");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
async submitPay(
|
|
|
|
contractTermsHash: string,
|
|
|
|
sessionId: string | undefined,
|
|
|
|
): Promise<ConfirmPayResult> {
|
2018-01-19 01:27:27 +01:00
|
|
|
const purchase = await this.q().get(Stores.purchases, contractTermsHash);
|
|
|
|
if (!purchase) {
|
|
|
|
throw Error("Purchase not found: " + contractTermsHash);
|
|
|
|
}
|
2018-01-29 16:41:17 +01:00
|
|
|
if (purchase.abortRequested) {
|
|
|
|
throw Error("not submitting payment for aborted purchase");
|
|
|
|
}
|
2018-01-17 03:49:54 +01:00
|
|
|
let resp;
|
|
|
|
const payReq = { ...purchase.payReq, session_id: sessionId };
|
2018-01-29 16:41:17 +01:00
|
|
|
|
2018-01-17 03:49:54 +01:00
|
|
|
try {
|
2019-08-24 18:42:00 +02:00
|
|
|
resp = await this.http.postJson(purchase.contractTerms.pay_url, payReq);
|
2018-01-17 03:49:54 +01:00
|
|
|
} catch (e) {
|
|
|
|
// Gives the user the option to retry / abort and refresh
|
|
|
|
console.log("payment failed", e);
|
|
|
|
throw e;
|
|
|
|
}
|
2019-08-22 23:36:36 +02:00
|
|
|
const merchantResp = resp.responseJson;
|
2018-01-17 03:49:54 +01:00
|
|
|
console.log("got success from pay_url");
|
2018-01-23 16:19:03 +01:00
|
|
|
|
|
|
|
const merchantPub = purchase.contractTerms.merchant_pub;
|
2019-06-26 15:30:32 +02:00
|
|
|
const valid: boolean = await this.cryptoApi.isValidPaymentSignature(
|
|
|
|
merchantResp.sig,
|
|
|
|
contractTermsHash,
|
|
|
|
merchantPub,
|
2018-01-23 16:19:03 +01:00
|
|
|
);
|
|
|
|
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 this.q().get<CoinRecord>(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 this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.putAll(Stores.coins, modifiedCoins)
|
|
|
|
.put(Stores.purchases, purchase)
|
|
|
|
.finish();
|
2018-01-23 16:19:03 +01:00
|
|
|
for (const c of purchase.payReq.coins) {
|
|
|
|
this.refresh(c.coin_pub);
|
|
|
|
}
|
|
|
|
|
2019-08-29 23:12:55 +02:00
|
|
|
const nextUrl = this.getNextUrl(purchase.contractTerms);
|
2019-06-26 15:30:32 +02:00
|
|
|
this.cachedNextUrl[purchase.contractTerms.fulfillment_url] = {
|
|
|
|
nextUrl,
|
|
|
|
lastSessionId: sessionId,
|
|
|
|
};
|
2019-09-04 15:28:19 +02:00
|
|
|
|
2018-01-17 03:49:54 +01:00
|
|
|
return { nextUrl };
|
|
|
|
}
|
|
|
|
|
2019-09-04 15:28:19 +02:00
|
|
|
/**
|
|
|
|
* 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 this.q()
|
|
|
|
.iter(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 };
|
|
|
|
}
|
|
|
|
|
2016-02-10 02:03:31 +01:00
|
|
|
/**
|
2018-01-29 16:41:17 +01:00
|
|
|
* Add a contract to the wallet and sign coins, and send them.
|
2016-02-10 02:03:31 +01:00
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
async confirmPay(
|
|
|
|
proposalId: number,
|
2019-08-24 18:42:00 +02:00
|
|
|
sessionIdOverride: string | undefined,
|
2019-06-26 15:30:32 +02:00
|
|
|
): Promise<ConfirmPayResult> {
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.log(
|
|
|
|
`executing confirmPay with proposalId ${proposalId} and sessionIdOverride ${sessionIdOverride}`,
|
|
|
|
);
|
2019-06-26 15:30:32 +02:00
|
|
|
const proposal: ProposalDownloadRecord | undefined = await this.q().get(
|
|
|
|
Stores.proposals,
|
|
|
|
proposalId,
|
|
|
|
);
|
2017-05-31 16:04:14 +02:00
|
|
|
|
|
|
|
if (!proposal) {
|
|
|
|
throw Error(`proposal with id ${proposalId} not found`);
|
|
|
|
}
|
2016-02-22 21:52:53 +01:00
|
|
|
|
2019-08-24 18:42:00 +02:00
|
|
|
const sessionId = sessionIdOverride || proposal.downloadSessionId;
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
let purchase = await this.q().get(
|
|
|
|
Stores.purchases,
|
|
|
|
proposal.contractTermsHash,
|
|
|
|
);
|
2016-05-24 01:53:56 +02:00
|
|
|
|
2017-08-27 03:56:19 +02:00
|
|
|
if (purchase) {
|
2018-01-19 01:27:27 +01:00
|
|
|
return this.submitPay(purchase.contractTermsHash, sessionId);
|
2016-09-28 18:54:48 +02:00
|
|
|
}
|
|
|
|
|
2018-01-29 22:58:47 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const res = await this.getCoinsForPayment({
|
2017-05-31 16:04:14 +02:00
|
|
|
allowedAuditors: proposal.contractTerms.auditors,
|
|
|
|
allowedExchanges: proposal.contractTerms.exchanges,
|
2018-01-29 22:58:47 +01:00
|
|
|
depositFeeLimit: Amounts.parseOrThrow(proposal.contractTerms.max_fee),
|
|
|
|
paymentAmount: Amounts.parseOrThrow(proposal.contractTerms.amount),
|
2017-05-31 16:04:14 +02:00
|
|
|
wireFeeAmortization: proposal.contractTerms.wire_fee_amortization || 1,
|
2018-01-29 22:58:47 +01:00
|
|
|
wireFeeLimit,
|
2017-05-31 16:04:14 +02:00
|
|
|
wireFeeTime: getTalerStampSec(proposal.contractTerms.timestamp) || 0,
|
|
|
|
wireMethod: proposal.contractTerms.wire_method,
|
2017-05-28 01:10:54 +02:00
|
|
|
});
|
2016-09-28 18:54:48 +02:00
|
|
|
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("coin selection result", res);
|
2016-11-20 04:15:49 +01:00
|
|
|
|
2016-11-14 02:52:29 +01:00
|
|
|
if (!res) {
|
2018-01-17 03:49:54 +01:00
|
|
|
// Should not happen, since checkPay should be called first
|
2016-09-28 18:54:48 +02:00
|
|
|
console.log("not confirming payment, insufficient coins");
|
2018-01-17 03:49:54 +01:00
|
|
|
throw Error("insufficient balance");
|
2016-09-28 18:54:48 +02:00
|
|
|
}
|
|
|
|
|
2017-12-12 21:54:14 +01:00
|
|
|
const sd = await this.getSpeculativePayData(proposalId);
|
|
|
|
if (!sd) {
|
2018-01-17 05:33:06 +01:00
|
|
|
const { exchangeUrl, cds, totalAmount } = res;
|
2019-06-26 15:30:32 +02:00
|
|
|
const payCoinInfo = await this.cryptoApi.signDeposit(
|
|
|
|
proposal.contractTerms,
|
|
|
|
cds,
|
|
|
|
totalAmount,
|
|
|
|
);
|
|
|
|
purchase = await this.recordConfirmPay(
|
|
|
|
proposal,
|
|
|
|
payCoinInfo,
|
|
|
|
exchangeUrl,
|
|
|
|
);
|
2017-12-12 21:54:14 +01:00
|
|
|
} else {
|
2019-06-26 15:30:32 +02:00
|
|
|
purchase = await this.recordConfirmPay(
|
|
|
|
sd.proposal,
|
|
|
|
sd.payCoinInfo,
|
|
|
|
sd.exchangeUrl,
|
|
|
|
);
|
2017-12-12 21:54:14 +01:00
|
|
|
}
|
|
|
|
|
2018-01-19 01:27:27 +01:00
|
|
|
return this.submitPay(purchase.contractTermsHash, sessionId);
|
2016-01-06 15:39:22 +01:00
|
|
|
}
|
2015-12-16 00:38:36 +01:00
|
|
|
|
2017-12-12 21:54:14 +01:00
|
|
|
/**
|
|
|
|
* Get the speculative pay data, but only if coins have not changed in between.
|
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
async getSpeculativePayData(
|
|
|
|
proposalId: number,
|
|
|
|
): Promise<SpeculativePayData | undefined> {
|
2017-12-12 21:54:14 +01:00
|
|
|
const sp = this.speculativePayData;
|
|
|
|
if (!sp) {
|
|
|
|
return;
|
|
|
|
}
|
2018-01-03 14:42:06 +01:00
|
|
|
if (sp.proposalId !== proposalId) {
|
2017-12-12 21:54:14 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
const coinKeys = sp.payCoinInfo.updatedCoins.map(x => x.coinPub);
|
|
|
|
const coins = await this.q().getMany(Stores.coins, coinKeys);
|
|
|
|
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;
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
if (
|
|
|
|
Amounts.cmp(specCoin.currentAmount, currentCoin.currentAmount) !== 0
|
|
|
|
) {
|
2018-01-03 14:42:06 +01:00
|
|
|
return;
|
2017-12-12 21:54:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return sp;
|
|
|
|
}
|
2016-02-10 02:03:31 +01:00
|
|
|
|
2019-08-29 23:12:55 +02:00
|
|
|
private async sendReserveInfoToBank(reservePub: string) {
|
|
|
|
const reserve = await this.q().get<ReserveRecord>(
|
|
|
|
Stores.reserves,
|
|
|
|
reservePub,
|
|
|
|
);
|
|
|
|
if (!reserve) {
|
|
|
|
throw Error("reserve not in db");
|
|
|
|
}
|
|
|
|
|
|
|
|
const bankStatusUrl = reserve.bankWithdrawStatusUrl;
|
|
|
|
if (!bankStatusUrl) {
|
|
|
|
throw Error("reserve not confirmed yet, and no status URL available.");
|
|
|
|
}
|
|
|
|
|
|
|
|
const now = new Date().getTime();
|
|
|
|
let status;
|
|
|
|
try {
|
|
|
|
const statusResp = await this.http.get(bankStatusUrl);
|
|
|
|
status = WithdrawOperationStatusResponse.checked(statusResp.responseJson);
|
|
|
|
} catch (e) {
|
|
|
|
console.log("bank error response", e);
|
|
|
|
throw e;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (status.transfer_done) {
|
|
|
|
await this.q().mutate(Stores.reserves, reservePub, r => {
|
|
|
|
r.timestamp_confirmed = now;
|
|
|
|
return r;
|
|
|
|
});
|
|
|
|
} else if (reserve.timestamp_reserve_info_posted === 0) {
|
|
|
|
try {
|
|
|
|
if (!status.selection_done) {
|
|
|
|
const bankResp = await this.http.postJson(bankStatusUrl, {
|
|
|
|
reserve_pub: reservePub,
|
|
|
|
selected_exchange: reserve.exchangeWire,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
} catch (e) {
|
|
|
|
console.log("bank error response", e);
|
|
|
|
throw e;
|
|
|
|
}
|
|
|
|
await this.q().mutate(Stores.reserves, reservePub, r => {
|
|
|
|
r.timestamp_reserve_info_posted = now;
|
|
|
|
return r;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-09 21:56:06 +01:00
|
|
|
/**
|
|
|
|
* First fetch information requred to withdraw from the reserve,
|
|
|
|
* then deplete the reserve, withdrawing coins until it is empty.
|
|
|
|
*/
|
2019-08-01 23:21:15 +02:00
|
|
|
async processReserve(reservePub: string): Promise<void> {
|
|
|
|
const activeOperation = this.activeProcessReserveOperations[reservePub];
|
|
|
|
|
|
|
|
if (activeOperation) {
|
|
|
|
return activeOperation;
|
|
|
|
}
|
|
|
|
|
|
|
|
const opId = "reserve-" + reservePub;
|
2016-05-24 02:05:19 +02:00
|
|
|
this.startOperation(opId);
|
2016-09-28 18:54:48 +02:00
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
// This opened promise gets resolved only once the
|
|
|
|
// reserve withdraw operation succeeds, even after retries.
|
|
|
|
const op = openPromise<void>();
|
|
|
|
|
|
|
|
const processReserveInternal = async (retryDelayMs: number = 250) => {
|
2019-08-28 02:49:27 +02:00
|
|
|
let isHardError = false;
|
|
|
|
// By default, do random, exponential backoff truncated at 3 minutes.
|
|
|
|
// Sometimes though, we want to try again faster.
|
|
|
|
let maxTimeout = 3000 * 60;
|
2019-08-01 23:21:15 +02:00
|
|
|
try {
|
2019-08-28 02:49:27 +02:00
|
|
|
const reserve = await this.q().get<ReserveRecord>(
|
|
|
|
Stores.reserves,
|
|
|
|
reservePub,
|
|
|
|
);
|
|
|
|
if (!reserve) {
|
|
|
|
isHardError = true;
|
|
|
|
throw Error("reserve not in db");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (reserve.timestamp_confirmed === 0) {
|
|
|
|
const bankStatusUrl = reserve.bankWithdrawStatusUrl;
|
|
|
|
if (!bankStatusUrl) {
|
|
|
|
isHardError = true;
|
|
|
|
throw Error(
|
|
|
|
"reserve not confirmed yet, and no status URL available.",
|
|
|
|
);
|
|
|
|
}
|
|
|
|
maxTimeout = 2000;
|
2019-08-29 23:12:55 +02:00
|
|
|
/* This path is only taken if the wallet crashed after a withdraw was accepted,
|
|
|
|
* and before the information could be sent to the bank. */
|
|
|
|
await this.sendReserveInfoToBank(reservePub);
|
|
|
|
throw Error("waiting for reserve to be confirmed");
|
2019-08-28 02:49:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const updatedReserve = await this.updateReserve(reservePub);
|
|
|
|
await this.depleteReserve(updatedReserve);
|
2019-08-01 23:21:15 +02:00
|
|
|
op.resolve();
|
|
|
|
} catch (e) {
|
2019-08-28 02:49:27 +02:00
|
|
|
if (isHardError) {
|
|
|
|
op.reject(e);
|
|
|
|
}
|
2019-08-01 23:21:15 +02:00
|
|
|
const nextDelay = Math.min(
|
|
|
|
2 * retryDelayMs + retryDelayMs * Math.random(),
|
2019-08-28 02:49:27 +02:00
|
|
|
maxTimeout,
|
2019-08-01 23:21:15 +02:00
|
|
|
);
|
2019-08-28 02:49:27 +02:00
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
this.timerGroup.after(retryDelayMs, () =>
|
|
|
|
processReserveInternal(nextDelay),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-09-28 18:54:48 +02:00
|
|
|
try {
|
2019-08-01 23:21:15 +02:00
|
|
|
processReserveInternal();
|
|
|
|
this.activeProcessReserveOperations[reservePub] = op.promise;
|
|
|
|
await op.promise;
|
2016-09-28 18:54:48 +02:00
|
|
|
} finally {
|
|
|
|
this.stopOperation(opId);
|
2019-08-01 23:21:15 +02:00
|
|
|
delete this.activeProcessReserveOperations[reservePub];
|
2016-09-28 18:54:48 +02:00
|
|
|
}
|
2016-05-24 01:18:23 +02:00
|
|
|
}
|
|
|
|
|
2017-10-15 18:30:02 +02:00
|
|
|
/**
|
|
|
|
* Given a planchet, withdraw a coin from the exchange.
|
|
|
|
*/
|
2019-08-01 23:21:15 +02:00
|
|
|
private async processPreCoin(preCoinPub: string): Promise<void> {
|
|
|
|
const activeOperation = this.activeProcessPreCoinOperations[preCoinPub];
|
|
|
|
if (activeOperation) {
|
|
|
|
return activeOperation;
|
2016-10-19 22:59:24 +02:00
|
|
|
}
|
2019-08-01 23:21:15 +02:00
|
|
|
|
|
|
|
const op = openPromise<void>();
|
|
|
|
|
|
|
|
const processPreCoinInternal = async (retryDelayMs: number = 200) => {
|
|
|
|
const preCoin = await this.q().get(Stores.precoins, preCoinPub);
|
|
|
|
if (!preCoin) {
|
|
|
|
console.log("processPreCoin: preCoinPub not found");
|
2016-11-17 01:23:53 +01:00
|
|
|
return;
|
|
|
|
}
|
2019-08-01 23:21:15 +02:00
|
|
|
// Throttle concurrent executions of this function,
|
|
|
|
// so we don't withdraw too many coins at once.
|
|
|
|
if (
|
|
|
|
this.processPreCoinConcurrent >= 4 ||
|
|
|
|
this.processPreCoinThrottle[preCoin.exchangeBaseUrl]
|
|
|
|
) {
|
2019-08-18 23:06:27 +02:00
|
|
|
const timeout = Math.min(retryDelayMs * 2, 5 * 60 * 1000);
|
2019-08-20 17:58:01 +02:00
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.log(
|
|
|
|
`throttling processPreCoin of ${preCoinPub} for ${timeout}ms`,
|
|
|
|
);
|
2019-08-18 23:06:27 +02:00
|
|
|
this.timerGroup.after(retryDelayMs, () => processPreCoinInternal());
|
2019-08-01 23:21:15 +02:00
|
|
|
return op.promise;
|
2016-11-17 01:23:53 +01:00
|
|
|
}
|
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
this.processPreCoinConcurrent++;
|
2016-10-20 01:37:00 +02:00
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
try {
|
|
|
|
const exchange = await this.q().get(
|
|
|
|
Stores.exchanges,
|
|
|
|
preCoin.exchangeBaseUrl,
|
2019-06-26 15:30:32 +02:00
|
|
|
);
|
2019-08-01 23:21:15 +02:00
|
|
|
if (!exchange) {
|
|
|
|
console.error("db inconsistent: exchange for precoin not found");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const denom = await this.q().get(Stores.denominations, [
|
|
|
|
preCoin.exchangeBaseUrl,
|
|
|
|
preCoin.denomPub,
|
|
|
|
]);
|
|
|
|
if (!denom) {
|
|
|
|
console.error("db inconsistent: denom for precoin not found");
|
|
|
|
return;
|
2016-10-19 22:59:24 +02:00
|
|
|
}
|
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
const coin = await this.withdrawExecute(preCoin);
|
2016-10-19 22:59:24 +02:00
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
const mutateReserve = (r: ReserveRecord) => {
|
|
|
|
const x = Amounts.sub(
|
|
|
|
r.precoin_amount,
|
|
|
|
preCoin.coinValue,
|
|
|
|
denom.feeWithdraw,
|
2019-06-26 15:30:32 +02:00
|
|
|
);
|
2019-08-01 23:21:15 +02:00
|
|
|
if (x.saturated) {
|
|
|
|
console.error("database inconsistent");
|
|
|
|
throw AbortTransaction;
|
|
|
|
}
|
|
|
|
r.precoin_amount = x.amount;
|
|
|
|
return r;
|
|
|
|
};
|
2017-11-30 04:07:36 +01:00
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
await this.q()
|
|
|
|
.mutate(Stores.reserves, preCoin.reservePub, mutateReserve)
|
|
|
|
.delete(Stores.precoins, coin.coinPub)
|
|
|
|
.add(Stores.coins, coin)
|
|
|
|
.finish();
|
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
this.badge.showNotification();
|
2017-11-30 04:07:36 +01:00
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
this.notifier.notify();
|
|
|
|
op.resolve();
|
|
|
|
} catch (e) {
|
|
|
|
console.error(
|
|
|
|
"Failed to withdraw coin from precoin, retrying in",
|
|
|
|
retryDelayMs,
|
|
|
|
"ms",
|
|
|
|
e,
|
|
|
|
);
|
|
|
|
// exponential backoff truncated at one minute
|
|
|
|
const nextRetryDelayMs = Math.min(retryDelayMs * 2, 5 * 60 * 1000);
|
|
|
|
this.timerGroup.after(retryDelayMs, () =>
|
|
|
|
processPreCoinInternal(nextRetryDelayMs),
|
|
|
|
);
|
2019-06-26 15:30:32 +02:00
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
const currentThrottle =
|
|
|
|
this.processPreCoinThrottle[preCoin.exchangeBaseUrl] || 0;
|
|
|
|
this.processPreCoinThrottle[preCoin.exchangeBaseUrl] =
|
|
|
|
currentThrottle + 1;
|
|
|
|
this.timerGroup.after(retryDelayMs, () => {
|
|
|
|
this.processPreCoinThrottle[preCoin.exchangeBaseUrl]--;
|
|
|
|
});
|
|
|
|
} finally {
|
|
|
|
this.processPreCoinConcurrent--;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
try {
|
|
|
|
this.activeProcessPreCoinOperations[preCoinPub] = op.promise;
|
|
|
|
await processPreCoinInternal();
|
|
|
|
return op.promise;
|
2016-11-17 01:23:53 +01:00
|
|
|
} finally {
|
2019-08-01 23:21:15 +02:00
|
|
|
delete this.activeProcessPreCoinOperations[preCoinPub];
|
2016-09-28 18:54:48 +02:00
|
|
|
}
|
2016-01-24 19:57:09 +01:00
|
|
|
}
|
|
|
|
|
2017-12-10 21:34:56 +01:00
|
|
|
/**
|
|
|
|
* Update the timestamp of when an exchange was used.
|
|
|
|
*/
|
|
|
|
async updateExchangeUsedTime(exchangeBaseUrl: string): Promise<void> {
|
2019-06-26 15:30:32 +02:00
|
|
|
const now = new Date().getTime();
|
2017-12-10 21:34:56 +01:00
|
|
|
const update = (r: ExchangeRecord) => {
|
|
|
|
r.lastUsedTime = now;
|
|
|
|
return r;
|
|
|
|
};
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.mutate(Stores.exchanges, exchangeBaseUrl, update)
|
|
|
|
.finish();
|
2017-12-10 21:34:56 +01:00
|
|
|
}
|
|
|
|
|
2016-02-09 21:56:06 +01:00
|
|
|
/**
|
|
|
|
* Create a reserve, but do not flag it as confirmed yet.
|
2017-04-28 23:28:27 +02:00
|
|
|
*
|
|
|
|
* Adds the corresponding exchange as a trusted exchange if it is neither
|
|
|
|
* audited nor trusted already.
|
2016-02-09 21:56:06 +01:00
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
async createReserve(
|
|
|
|
req: CreateReserveRequest,
|
|
|
|
): Promise<CreateReserveResponse> {
|
2017-05-28 01:10:54 +02:00
|
|
|
const keypair = await this.cryptoApi.createEddsaKeypair();
|
2019-06-26 15:30:32 +02:00
|
|
|
const now = new Date().getTime();
|
2016-09-28 18:54:48 +02:00
|
|
|
const canonExchange = canonicalizeBaseUrl(req.exchange);
|
|
|
|
|
2016-09-28 23:41:34 +02:00
|
|
|
const reserveRecord: ReserveRecord = {
|
2016-09-28 18:54:48 +02:00
|
|
|
created: now,
|
|
|
|
current_amount: null,
|
2017-05-28 01:10:54 +02:00
|
|
|
exchange_base_url: canonExchange,
|
|
|
|
hasPayback: false,
|
2016-10-20 01:37:00 +02:00
|
|
|
precoin_amount: Amounts.getZero(req.amount.currency),
|
2017-05-28 01:10:54 +02:00
|
|
|
requested_amount: req.amount,
|
|
|
|
reserve_priv: keypair.priv,
|
|
|
|
reserve_pub: keypair.pub,
|
2017-08-14 04:16:12 +02:00
|
|
|
senderWire: req.senderWire,
|
2017-10-15 18:30:02 +02:00
|
|
|
timestamp_confirmed: 0,
|
2019-08-28 02:49:27 +02:00
|
|
|
timestamp_reserve_info_posted: 0,
|
2017-10-15 18:30:02 +02:00
|
|
|
timestamp_depleted: 0,
|
2019-08-28 02:49:27 +02:00
|
|
|
bankWithdrawStatusUrl: req.bankWithdrawStatusUrl,
|
|
|
|
exchangeWire: req.exchangeWire,
|
2016-09-28 18:54:48 +02:00
|
|
|
};
|
2016-01-06 15:39:22 +01:00
|
|
|
|
2018-01-04 11:08:39 +01:00
|
|
|
const senderWire = req.senderWire;
|
2019-05-08 04:53:26 +02:00
|
|
|
if (senderWire) {
|
2018-01-04 11:08:39 +01:00
|
|
|
const rec = {
|
2019-05-08 04:53:26 +02:00
|
|
|
paytoUri: senderWire,
|
2018-01-04 11:08:39 +01:00
|
|
|
};
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.put(Stores.senderWires, rec)
|
|
|
|
.finish();
|
2018-01-04 11:08:39 +01:00
|
|
|
}
|
|
|
|
|
2017-12-10 21:34:56 +01:00
|
|
|
await this.updateExchangeUsedTime(req.exchange);
|
2017-05-28 01:10:54 +02:00
|
|
|
const exchangeInfo = await this.updateExchangeFromUrl(req.exchange);
|
2019-06-26 15:30:32 +02:00
|
|
|
const { isAudited, isTrusted } = await this.getExchangeTrust(exchangeInfo);
|
|
|
|
let currencyRecord = await this.q().get(
|
|
|
|
Stores.currencies,
|
|
|
|
exchangeInfo.currency,
|
|
|
|
);
|
2017-04-28 23:28:27 +02:00
|
|
|
if (!currencyRecord) {
|
|
|
|
currencyRecord = {
|
|
|
|
auditors: [],
|
2017-05-28 01:10:54 +02:00
|
|
|
exchanges: [],
|
|
|
|
fractionalDigits: 2,
|
|
|
|
name: exchangeInfo.currency,
|
|
|
|
};
|
2017-04-28 23:28:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!isAudited && !isTrusted) {
|
2019-06-26 15:30:32 +02:00
|
|
|
currencyRecord.exchanges.push({
|
|
|
|
baseUrl: req.exchange,
|
|
|
|
exchangePub: exchangeInfo.masterPublicKey,
|
|
|
|
});
|
2017-04-28 23:28:27 +02:00
|
|
|
}
|
|
|
|
|
2016-10-13 02:23:24 +02:00
|
|
|
await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.put(Stores.currencies, currencyRecord)
|
|
|
|
.put(Stores.reserves, reserveRecord)
|
|
|
|
.finish();
|
2016-02-11 18:17:02 +01:00
|
|
|
|
2019-08-28 02:49:27 +02:00
|
|
|
if (req.bankWithdrawStatusUrl) {
|
|
|
|
this.processReserve(keypair.pub);
|
|
|
|
}
|
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const r: CreateReserveResponse = {
|
2016-09-28 18:54:48 +02:00
|
|
|
exchange: canonExchange,
|
|
|
|
reservePub: keypair.pub,
|
|
|
|
};
|
|
|
|
return r;
|
2016-02-09 21:56:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Mark an existing reserve as confirmed. The wallet will start trying
|
|
|
|
* to withdraw from that reserve. This may not immediately succeed,
|
2016-03-01 19:39:17 +01:00
|
|
|
* since the exchange might not know about the reserve yet, even though the
|
2016-02-09 21:56:06 +01:00
|
|
|
* bank confirmed its creation.
|
|
|
|
*
|
|
|
|
* A confirmed reserve should be shown to the user in the UI, while
|
|
|
|
* an unconfirmed reserve should be hidden.
|
|
|
|
*/
|
2016-09-28 18:54:48 +02:00
|
|
|
async confirmReserve(req: ConfirmReserveRequest): Promise<void> {
|
2019-06-26 15:30:32 +02:00
|
|
|
const now = new Date().getTime();
|
|
|
|
const reserve: ReserveRecord | undefined = await this.q().get<
|
|
|
|
ReserveRecord
|
|
|
|
>(Stores.reserves, req.reservePub);
|
2016-10-13 02:23:24 +02:00
|
|
|
if (!reserve) {
|
|
|
|
console.error("Unable to confirm reserve, not found in DB");
|
|
|
|
return;
|
|
|
|
}
|
2017-10-15 18:30:02 +02:00
|
|
|
reserve.timestamp_confirmed = now;
|
2016-10-13 02:23:24 +02:00
|
|
|
await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.put(Stores.reserves, reserve)
|
|
|
|
.finish();
|
2016-10-19 22:49:03 +02:00
|
|
|
this.notifier.notify();
|
2016-09-28 19:09:10 +02:00
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
this.processReserve(reserve.reserve_pub);
|
2015-12-16 05:53:55 +01:00
|
|
|
}
|
2016-01-05 01:10:31 +01:00
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
private async withdrawExecute(pc: PreCoinRecord): Promise<CoinRecord> {
|
2017-05-28 01:10:54 +02:00
|
|
|
const wd: any = {};
|
2019-05-08 07:01:17 +02:00
|
|
|
wd.denom_pub_hash = pc.denomPubHash;
|
2016-09-28 18:54:48 +02:00
|
|
|
wd.reserve_pub = pc.reservePub;
|
|
|
|
wd.reserve_sig = pc.withdrawSig;
|
|
|
|
wd.coin_ev = pc.coinEv;
|
2019-06-26 15:30:32 +02:00
|
|
|
const reqUrl = new URI("reserve/withdraw").absoluteTo(pc.exchangeBaseUrl);
|
2017-05-28 01:10:54 +02:00
|
|
|
const resp = await this.http.postJson(reqUrl.href(), wd);
|
2016-09-28 18:54:48 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
if (resp.status !== 200) {
|
2016-09-28 18:54:48 +02:00
|
|
|
throw new RequestException({
|
|
|
|
hint: "Withdrawal failed",
|
2017-05-28 01:10:54 +02:00
|
|
|
status: resp.status,
|
2016-01-06 15:39:22 +01:00
|
|
|
});
|
2016-09-28 18:54:48 +02:00
|
|
|
}
|
2019-07-31 01:33:56 +02:00
|
|
|
const r = resp.responseJson;
|
2019-06-26 15:30:32 +02:00
|
|
|
const denomSig = await this.cryptoApi.rsaUnblind(
|
|
|
|
r.ev_sig,
|
|
|
|
pc.blindingKey,
|
|
|
|
pc.denomPub,
|
|
|
|
);
|
2017-05-28 01:10:54 +02:00
|
|
|
const coin: CoinRecord = {
|
2017-05-01 04:33:47 +02:00
|
|
|
blindingKey: pc.blindingKey,
|
2017-05-28 01:10:54 +02:00
|
|
|
coinPriv: pc.coinPriv,
|
|
|
|
coinPub: pc.coinPub,
|
2016-09-28 18:54:48 +02:00
|
|
|
currentAmount: pc.coinValue,
|
2017-05-28 01:10:54 +02:00
|
|
|
denomPub: pc.denomPub,
|
2019-05-08 07:01:17 +02:00
|
|
|
denomPubHash: pc.denomPubHash,
|
2017-05-28 01:10:54 +02:00
|
|
|
denomSig,
|
2016-09-28 18:54:48 +02:00
|
|
|
exchangeBaseUrl: pc.exchangeBaseUrl,
|
2017-05-28 01:10:54 +02:00
|
|
|
reservePub: pc.reservePub,
|
2019-08-30 17:27:59 +02:00
|
|
|
status: CoinStatus.Fresh,
|
2016-09-28 18:54:48 +02:00
|
|
|
};
|
|
|
|
return coin;
|
2016-01-06 15:39:22 +01:00
|
|
|
}
|
2015-12-13 23:47:30 +01:00
|
|
|
|
2016-01-06 15:39:22 +01:00
|
|
|
/**
|
|
|
|
* Withdraw coins from a reserve until it is empty.
|
2017-10-15 18:30:02 +02:00
|
|
|
*
|
|
|
|
* When finished, marks the reserve as depleted by setting
|
|
|
|
* the depleted timestamp.
|
2016-01-06 15:39:22 +01:00
|
|
|
*/
|
2017-10-15 18:30:02 +02:00
|
|
|
private async depleteReserve(reserve: ReserveRecord): Promise<void> {
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("depleting reserve");
|
2016-10-20 01:37:00 +02:00
|
|
|
if (!reserve.current_amount) {
|
|
|
|
throw Error("can't withdraw when amount is unknown");
|
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
const withdrawAmount = reserve.current_amount;
|
|
|
|
if (!withdrawAmount) {
|
2016-11-16 01:59:39 +01:00
|
|
|
throw Error("can't withdraw when amount is unknown");
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
const denomsForWithdraw = await this.getVerifiedWithdrawDenomList(
|
|
|
|
reserve.exchange_base_url,
|
|
|
|
withdrawAmount,
|
|
|
|
);
|
|
|
|
const smallestAmount = await this.getVerifiedSmallestWithdrawAmount(
|
|
|
|
reserve.exchange_base_url,
|
|
|
|
);
|
2016-02-11 18:17:02 +01:00
|
|
|
|
2016-11-18 00:09:43 +01:00
|
|
|
console.log(`withdrawing ${denomsForWithdraw.length} coins`);
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const ps = denomsForWithdraw.map(async denom => {
|
2016-10-20 01:37:00 +02:00
|
|
|
function mutateReserve(r: ReserveRecord): ReserveRecord {
|
2017-05-28 01:10:54 +02:00
|
|
|
const currentAmount = r.current_amount;
|
2016-10-20 01:37:00 +02:00
|
|
|
if (!currentAmount) {
|
|
|
|
throw Error("can't withdraw when amount is unknown");
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
r.precoin_amount = Amounts.add(
|
|
|
|
r.precoin_amount,
|
|
|
|
denom.value,
|
|
|
|
denom.feeWithdraw,
|
|
|
|
).amount;
|
|
|
|
const result = Amounts.sub(
|
|
|
|
currentAmount,
|
|
|
|
denom.value,
|
|
|
|
denom.feeWithdraw,
|
|
|
|
);
|
2016-10-20 01:37:00 +02:00
|
|
|
if (result.saturated) {
|
|
|
|
console.error("can't create precoin, saturated");
|
|
|
|
throw AbortTransaction;
|
|
|
|
}
|
|
|
|
r.current_amount = result.amount;
|
|
|
|
|
2017-10-15 18:30:02 +02:00
|
|
|
// Reserve is depleted if the amount left is too small to withdraw
|
|
|
|
if (Amounts.cmp(r.current_amount, smallestAmount) < 0) {
|
2019-06-26 15:30:32 +02:00
|
|
|
r.timestamp_depleted = new Date().getTime();
|
2017-10-15 18:30:02 +02:00
|
|
|
}
|
|
|
|
|
2016-10-20 01:37:00 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const preCoin = await this.cryptoApi.createPreCoin(denom, reserve);
|
2019-08-28 02:49:27 +02:00
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
// This will fail and throw an exception if the remaining amount in the
|
|
|
|
// reserve is too low to create a pre-coin.
|
|
|
|
try {
|
|
|
|
await this.q()
|
|
|
|
.put(Stores.precoins, preCoin)
|
|
|
|
.mutate(Stores.reserves, reserve.reserve_pub, mutateReserve)
|
|
|
|
.finish();
|
2019-08-28 02:49:27 +02:00
|
|
|
console.log("created precoin", preCoin.coinPub);
|
2019-08-01 23:21:15 +02:00
|
|
|
} catch (e) {
|
|
|
|
console.log("can't create pre-coin:", e.name, e.message);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
await this.processPreCoin(preCoin.coinPub);
|
2016-10-19 22:59:24 +02:00
|
|
|
});
|
2016-10-20 01:37:00 +02:00
|
|
|
|
2016-09-28 17:52:36 +02:00
|
|
|
await Promise.all(ps);
|
2016-01-06 15:39:22 +01:00
|
|
|
}
|
|
|
|
|
2016-02-11 18:17:02 +01:00
|
|
|
/**
|
|
|
|
* Update the information about a reserve that is stored in the wallet
|
2016-03-01 19:39:17 +01:00
|
|
|
* by quering the reserve's exchange.
|
2016-02-11 18:17:02 +01:00
|
|
|
*/
|
2017-05-01 04:05:16 +02:00
|
|
|
private async updateReserve(reservePub: string): Promise<ReserveRecord> {
|
2019-06-26 15:30:32 +02:00
|
|
|
const reserve = await this.q().get<ReserveRecord>(
|
|
|
|
Stores.reserves,
|
|
|
|
reservePub,
|
|
|
|
);
|
2016-10-13 02:23:24 +02:00
|
|
|
if (!reserve) {
|
|
|
|
throw Error("reserve not in db");
|
|
|
|
}
|
2019-08-28 02:49:27 +02:00
|
|
|
|
|
|
|
if (reserve.timestamp_confirmed === 0) {
|
|
|
|
throw Error("");
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const reqUrl = new URI("reserve/status").absoluteTo(
|
|
|
|
reserve.exchange_base_url,
|
|
|
|
);
|
|
|
|
reqUrl.query({ reserve_pub: reservePub });
|
2017-05-28 01:10:54 +02:00
|
|
|
const resp = await this.http.get(reqUrl.href());
|
|
|
|
if (resp.status !== 200) {
|
2019-08-18 23:06:27 +02:00
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.warn(`reserve/status returned ${resp.status}`);
|
2016-09-28 19:09:10 +02:00
|
|
|
throw Error();
|
|
|
|
}
|
2019-07-31 01:33:56 +02:00
|
|
|
const reserveInfo = ReserveStatus.checked(resp.responseJson);
|
2016-09-28 19:09:10 +02:00
|
|
|
if (!reserveInfo) {
|
|
|
|
throw Error();
|
|
|
|
}
|
2018-01-29 22:58:47 +01:00
|
|
|
reserve.current_amount = Amounts.parseOrThrow(reserveInfo.balance);
|
2016-10-13 02:23:24 +02:00
|
|
|
await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.put(Stores.reserves, reserve)
|
|
|
|
.finish();
|
2016-10-19 22:49:03 +02:00
|
|
|
this.notifier.notify();
|
2016-09-28 19:09:10 +02:00
|
|
|
return reserve;
|
2016-01-06 15:39:22 +01:00
|
|
|
}
|
|
|
|
|
2016-05-24 00:36:20 +02:00
|
|
|
/**
|
|
|
|
* Get the wire information for the exchange with the given base URL.
|
|
|
|
*/
|
2019-05-08 04:53:26 +02:00
|
|
|
async getWireInfo(exchangeBaseUrl: string): Promise<ExchangeWireJson> {
|
2016-05-24 00:36:20 +02:00
|
|
|
exchangeBaseUrl = canonicalizeBaseUrl(exchangeBaseUrl);
|
2019-09-06 12:34:05 +02:00
|
|
|
const reqUrl = new URI("wire")
|
|
|
|
.absoluteTo(exchangeBaseUrl)
|
|
|
|
.addQuery("cacheBreaker", WALLET_CACHE_BREAKER_CLIENT_VERSION);
|
2017-05-28 01:10:54 +02:00
|
|
|
const resp = await this.http.get(reqUrl.href());
|
2016-04-06 02:06:57 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
if (resp.status !== 200) {
|
2016-09-28 18:54:48 +02:00
|
|
|
throw Error("/wire request failed");
|
|
|
|
}
|
|
|
|
|
2019-07-31 01:33:56 +02:00
|
|
|
const wiJson = resp.responseJson;
|
2016-09-28 18:54:48 +02:00
|
|
|
if (!wiJson) {
|
2017-05-28 01:10:54 +02:00
|
|
|
throw Error("/wire response malformed");
|
2016-09-28 18:54:48 +02:00
|
|
|
}
|
2019-06-03 23:34:59 +02:00
|
|
|
|
|
|
|
return ExchangeWireJson.checked(wiJson);
|
2016-04-06 02:06:57 +02:00
|
|
|
}
|
|
|
|
|
2016-11-16 01:59:39 +01:00
|
|
|
async getPossibleDenoms(exchangeBaseUrl: string) {
|
2019-06-26 15:30:32 +02:00
|
|
|
return this.q()
|
|
|
|
.iterIndex(Stores.denominations.exchangeBaseUrlIndex, exchangeBaseUrl)
|
|
|
|
.filter(
|
|
|
|
d =>
|
|
|
|
d.status === DenominationStatus.Unverified ||
|
|
|
|
d.status === DenominationStatus.VerifiedGood,
|
|
|
|
)
|
|
|
|
.toArray();
|
2016-11-16 01:59:39 +01:00
|
|
|
}
|
|
|
|
|
2017-10-15 18:30:02 +02:00
|
|
|
/**
|
|
|
|
* Compute the smallest withdrawable amount possible, based on verified denominations.
|
|
|
|
*
|
|
|
|
* Writes to the DB in order to record the result from verifying
|
|
|
|
* denominations.
|
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
async getVerifiedSmallestWithdrawAmount(
|
|
|
|
exchangeBaseUrl: string,
|
|
|
|
): Promise<AmountJson> {
|
2017-10-15 18:30:02 +02:00
|
|
|
const exchange = await this.q().get(Stores.exchanges, exchangeBaseUrl);
|
|
|
|
if (!exchange) {
|
|
|
|
throw Error(`exchange ${exchangeBaseUrl} not found`);
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const possibleDenoms = await this.q()
|
|
|
|
.iterIndex(Stores.denominations.exchangeBaseUrlIndex, exchange.baseUrl)
|
|
|
|
.filter(
|
|
|
|
d =>
|
|
|
|
d.status === DenominationStatus.Unverified ||
|
|
|
|
d.status === DenominationStatus.VerifiedGood,
|
|
|
|
)
|
|
|
|
.toArray();
|
2017-10-15 18:30:02 +02:00
|
|
|
possibleDenoms.sort((d1, d2) => {
|
2017-10-15 19:28:35 +02:00
|
|
|
const a1 = Amounts.add(d1.feeWithdraw, d1.value).amount;
|
|
|
|
const a2 = Amounts.add(d2.feeWithdraw, d2.value).amount;
|
2017-10-15 18:30:02 +02:00
|
|
|
return Amounts.cmp(a1, a2);
|
|
|
|
});
|
|
|
|
|
2017-10-15 19:28:35 +02:00
|
|
|
for (const denom of possibleDenoms) {
|
2017-10-15 18:30:02 +02:00
|
|
|
if (denom.status === DenominationStatus.VerifiedGood) {
|
|
|
|
return Amounts.add(denom.feeWithdraw, denom.value).amount;
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
const valid = await this.cryptoApi.isValidDenom(
|
|
|
|
denom,
|
|
|
|
exchange.masterPublicKey,
|
|
|
|
);
|
2017-10-15 18:30:02 +02:00
|
|
|
if (!valid) {
|
|
|
|
denom.status = DenominationStatus.VerifiedBad;
|
|
|
|
} else {
|
|
|
|
denom.status = DenominationStatus.VerifiedGood;
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.put(Stores.denominations, denom)
|
|
|
|
.finish();
|
2017-10-15 18:30:02 +02:00
|
|
|
if (valid) {
|
|
|
|
return Amounts.add(denom.feeWithdraw, denom.value).amount;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Amounts.getZero(exchange.currency);
|
|
|
|
}
|
|
|
|
|
2016-11-16 01:59:39 +01:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
async getVerifiedWithdrawDenomList(
|
|
|
|
exchangeBaseUrl: string,
|
|
|
|
amount: AmountJson,
|
|
|
|
): Promise<DenominationRecord[]> {
|
2016-11-16 01:59:39 +01:00
|
|
|
const exchange = await this.q().get(Stores.exchanges, exchangeBaseUrl);
|
|
|
|
if (!exchange) {
|
|
|
|
throw Error(`exchange ${exchangeBaseUrl} not found`);
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const possibleDenoms = await this.q()
|
|
|
|
.iterIndex(Stores.denominations.exchangeBaseUrlIndex, exchange.baseUrl)
|
|
|
|
.filter(
|
|
|
|
d =>
|
|
|
|
d.status === DenominationStatus.Unverified ||
|
|
|
|
d.status === DenominationStatus.VerifiedGood,
|
|
|
|
)
|
|
|
|
.toArray();
|
2016-11-16 01:59:39 +01:00
|
|
|
|
|
|
|
let allValid = false;
|
|
|
|
|
|
|
|
let selectedDenoms: DenominationRecord[];
|
|
|
|
|
|
|
|
do {
|
|
|
|
allValid = true;
|
2017-05-28 01:10:54 +02:00
|
|
|
const nextPossibleDenoms = [];
|
2016-11-16 01:59:39 +01:00
|
|
|
selectedDenoms = getWithdrawDenomList(amount, possibleDenoms);
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const denom of selectedDenoms || []) {
|
|
|
|
if (denom.status === DenominationStatus.Unverified) {
|
2019-06-26 15:30:32 +02:00
|
|
|
const valid = await this.cryptoApi.isValidDenom(
|
|
|
|
denom,
|
|
|
|
exchange.masterPublicKey,
|
|
|
|
);
|
2016-11-16 01:59:39 +01:00
|
|
|
if (!valid) {
|
|
|
|
denom.status = DenominationStatus.VerifiedBad;
|
|
|
|
allValid = false;
|
|
|
|
} else {
|
|
|
|
denom.status = DenominationStatus.VerifiedGood;
|
|
|
|
nextPossibleDenoms.push(denom);
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.put(Stores.denominations, denom)
|
|
|
|
.finish();
|
2016-11-16 01:59:39 +01:00
|
|
|
} else {
|
|
|
|
nextPossibleDenoms.push(denom);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (selectedDenoms.length > 0 && !allValid);
|
|
|
|
|
|
|
|
return selectedDenoms;
|
|
|
|
}
|
|
|
|
|
2017-04-28 23:28:27 +02:00
|
|
|
/**
|
|
|
|
* Check if and how an exchange is trusted and/or audited.
|
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
async getExchangeTrust(
|
|
|
|
exchangeInfo: ExchangeRecord,
|
|
|
|
): Promise<{ isTrusted: boolean; isAudited: boolean }> {
|
2017-04-28 23:28:27 +02:00
|
|
|
let isTrusted = false;
|
|
|
|
let isAudited = false;
|
2019-06-26 15:30:32 +02:00
|
|
|
const currencyRecord = await this.q().get(
|
|
|
|
Stores.currencies,
|
|
|
|
exchangeInfo.currency,
|
|
|
|
);
|
2017-04-28 23:28:27 +02:00
|
|
|
if (currencyRecord) {
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const trustedExchange of currencyRecord.exchanges) {
|
2017-06-04 20:25:28 +02:00
|
|
|
if (trustedExchange.exchangePub === exchangeInfo.masterPublicKey) {
|
2017-04-28 23:28:27 +02:00
|
|
|
isTrusted = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const trustedAuditor of currencyRecord.auditors) {
|
|
|
|
for (const exchangeAuditor of exchangeInfo.auditors) {
|
2017-06-04 20:25:28 +02:00
|
|
|
if (trustedAuditor.auditorPub === exchangeAuditor.auditor_pub) {
|
2017-04-28 23:28:27 +02:00
|
|
|
isAudited = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
return { isTrusted, isAudited };
|
2017-04-28 23:28:27 +02:00
|
|
|
}
|
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
async getWithdrawDetailsForUri(
|
|
|
|
talerWithdrawUri: string,
|
2019-08-29 23:12:55 +02:00
|
|
|
maybeSelectedExchange?: string,
|
|
|
|
): Promise<WithdrawDetails> {
|
2019-09-01 01:05:38 +02:00
|
|
|
const info = await this.getWithdrawalInfo(talerWithdrawUri);
|
2019-08-29 23:12:55 +02:00
|
|
|
let rci: ReserveCreationInfo | undefined = undefined;
|
|
|
|
if (maybeSelectedExchange) {
|
2019-08-30 17:27:59 +02:00
|
|
|
rci = await this.getWithdrawDetailsForAmount(
|
2019-08-29 23:12:55 +02:00
|
|
|
maybeSelectedExchange,
|
|
|
|
info.amount,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
return {
|
|
|
|
withdrawInfo: info,
|
|
|
|
reserveCreationInfo: rci,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
async getWithdrawDetailsForAmount(
|
2019-06-26 15:30:32 +02:00
|
|
|
baseUrl: string,
|
|
|
|
amount: AmountJson,
|
|
|
|
): Promise<ReserveCreationInfo> {
|
2017-05-28 01:10:54 +02:00
|
|
|
const exchangeInfo = await this.updateExchangeFromUrl(baseUrl);
|
2016-04-06 02:06:57 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const selectedDenoms = await this.getVerifiedWithdrawDenomList(
|
|
|
|
baseUrl,
|
|
|
|
amount,
|
|
|
|
);
|
2016-09-28 18:54:48 +02:00
|
|
|
let acc = Amounts.getZero(amount.currency);
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const d of selectedDenoms) {
|
2016-11-16 01:59:39 +01:00
|
|
|
acc = Amounts.add(acc, d.feeWithdraw).amount;
|
2016-09-28 18:54:48 +02:00
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
const actualCoinCost = selectedDenoms
|
2019-06-26 15:30:32 +02:00
|
|
|
.map(
|
|
|
|
(d: DenominationRecord) => Amounts.add(d.value, d.feeWithdraw).amount,
|
|
|
|
)
|
2016-09-28 18:54:48 +02:00
|
|
|
.reduce((a, b) => Amounts.add(a, b).amount);
|
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const wireInfo = await this.getWireInfo(baseUrl);
|
2016-09-28 18:54:48 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const wireFees = await this.q().get(Stores.exchangeWireFees, baseUrl);
|
2017-04-28 23:28:27 +02:00
|
|
|
if (!wireFees) {
|
|
|
|
// should never happen unless DB is inconsistent
|
|
|
|
throw Error(`no wire fees found for exchange ${baseUrl}`);
|
|
|
|
}
|
|
|
|
|
2019-05-08 04:53:26 +02:00
|
|
|
const exchangeWireAccounts: string[] = [];
|
|
|
|
for (let account of wireInfo.accounts) {
|
|
|
|
exchangeWireAccounts.push(account.url);
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const { isTrusted, isAudited } = await this.getExchangeTrust(exchangeInfo);
|
2017-04-28 23:28:27 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
let earliestDepositExpiration = Infinity;
|
|
|
|
for (const denom of selectedDenoms) {
|
|
|
|
const expireDeposit = getTalerStampSec(denom.stampExpireDeposit)!;
|
2017-04-28 23:42:14 +02:00
|
|
|
if (expireDeposit < earliestDepositExpiration) {
|
|
|
|
earliestDepositExpiration = expireDeposit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const possibleDenoms =
|
|
|
|
(await this.q()
|
|
|
|
.iterIndex(Stores.denominations.exchangeBaseUrlIndex, baseUrl)
|
|
|
|
.filter(d => d.isOffered)
|
|
|
|
.toArray()) || [];
|
2017-06-04 18:46:32 +02:00
|
|
|
|
2017-06-04 19:41:43 +02:00
|
|
|
const trustedAuditorPubs = [];
|
2019-06-26 15:30:32 +02:00
|
|
|
const currencyRecord = await this.q().get<CurrencyRecord>(
|
|
|
|
Stores.currencies,
|
|
|
|
amount.currency,
|
|
|
|
);
|
2017-06-04 19:41:43 +02:00
|
|
|
if (currencyRecord) {
|
2019-06-26 15:30:32 +02:00
|
|
|
trustedAuditorPubs.push(
|
|
|
|
...currencyRecord.auditors.map(a => a.auditorPub),
|
|
|
|
);
|
2017-06-04 18:46:32 +02:00
|
|
|
}
|
|
|
|
|
2017-06-04 20:16:09 +02:00
|
|
|
let versionMatch;
|
|
|
|
if (exchangeInfo.protocolVersion) {
|
2019-06-26 15:30:32 +02:00
|
|
|
versionMatch = LibtoolVersion.compare(
|
|
|
|
WALLET_PROTOCOL_VERSION,
|
|
|
|
exchangeInfo.protocolVersion,
|
|
|
|
);
|
|
|
|
|
|
|
|
if (
|
|
|
|
versionMatch &&
|
|
|
|
!versionMatch.compatible &&
|
|
|
|
versionMatch.currentCmp === -1
|
|
|
|
) {
|
2017-06-04 20:16:09 +02:00
|
|
|
console.log("wallet version might be outdated, checking for updates");
|
|
|
|
chrome.runtime.requestUpdateCheck((status, details) => {
|
|
|
|
console.log("update check status:", status);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const ret: ReserveCreationInfo = {
|
|
|
|
earliestDepositExpiration,
|
2016-09-28 18:54:48 +02:00
|
|
|
exchangeInfo,
|
2019-05-08 04:53:26 +02:00
|
|
|
exchangeWireAccounts,
|
2018-01-03 14:42:06 +01:00
|
|
|
exchangeVersion: exchangeInfo.protocolVersion || "unknown",
|
2017-04-28 23:28:27 +02:00
|
|
|
isAudited,
|
|
|
|
isTrusted,
|
2017-06-04 18:46:32 +02:00
|
|
|
numOfferedDenoms: possibleDenoms.length,
|
2016-09-28 18:54:48 +02:00
|
|
|
overhead: Amounts.sub(amount, actualCoinCost).amount,
|
2017-05-28 01:10:54 +02:00
|
|
|
selectedDenoms,
|
2017-06-04 18:46:32 +02:00
|
|
|
trustedAuditorPubs,
|
2017-10-15 19:28:35 +02:00
|
|
|
versionMatch,
|
2018-01-03 14:42:06 +01:00
|
|
|
walletVersion: WALLET_PROTOCOL_VERSION,
|
2017-05-28 01:10:54 +02:00
|
|
|
wireFees,
|
|
|
|
withdrawFee: acc,
|
2016-09-28 18:54:48 +02:00
|
|
|
};
|
|
|
|
return ret;
|
2016-02-18 22:50:17 +01:00
|
|
|
}
|
|
|
|
|
2019-08-01 23:21:15 +02:00
|
|
|
async getExchangePaytoUri(
|
|
|
|
exchangeBaseUrl: string,
|
|
|
|
supportedTargetTypes: string[],
|
|
|
|
): Promise<string> {
|
2019-07-31 01:33:56 +02:00
|
|
|
const wireInfo = await this.getWireInfo(exchangeBaseUrl);
|
|
|
|
for (let account of wireInfo.accounts) {
|
|
|
|
const paytoUri = new URI(account.url);
|
|
|
|
if (supportedTargetTypes.includes(paytoUri.authority())) {
|
|
|
|
return account.url;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
throw Error("no matching exchange account found");
|
|
|
|
}
|
|
|
|
|
2016-01-06 15:39:22 +01:00
|
|
|
/**
|
2016-03-01 19:39:17 +01:00
|
|
|
* Update or add exchange DB entry by fetching the /keys information.
|
2016-01-06 15:39:22 +01:00
|
|
|
* Optionally link the reserve entry to the new or existing
|
2016-03-01 19:39:17 +01:00
|
|
|
* exchange entry in then DB.
|
2016-01-06 15:39:22 +01:00
|
|
|
*/
|
2016-11-15 15:07:17 +01:00
|
|
|
async updateExchangeFromUrl(baseUrl: string): Promise<ExchangeRecord> {
|
2016-02-18 22:50:17 +01:00
|
|
|
baseUrl = canonicalizeBaseUrl(baseUrl);
|
2019-09-04 15:28:19 +02:00
|
|
|
const keysUrl = new URI("keys")
|
|
|
|
.absoluteTo(baseUrl)
|
2019-09-06 12:34:05 +02:00
|
|
|
.addQuery("cacheBreaker", WALLET_CACHE_BREAKER_CLIENT_VERSION);
|
2017-05-28 01:10:54 +02:00
|
|
|
const keysResp = await this.http.get(keysUrl.href());
|
|
|
|
if (keysResp.status !== 200) {
|
2016-09-28 18:54:48 +02:00
|
|
|
throw Error("/keys request failed");
|
|
|
|
}
|
2019-07-31 01:33:56 +02:00
|
|
|
const exchangeKeysJson = KeysJson.checked(keysResp.responseJson);
|
2019-05-08 04:53:26 +02:00
|
|
|
const exchangeWire = await this.getWireInfo(baseUrl);
|
|
|
|
return this.updateExchangeFromJson(baseUrl, exchangeKeysJson, exchangeWire);
|
2016-05-24 17:30:27 +02:00
|
|
|
}
|
2016-02-18 22:50:17 +01:00
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
private async suspendCoins(exchangeInfo: ExchangeRecord): Promise<void> {
|
2019-06-26 15:30:32 +02:00
|
|
|
const resultSuspendedCoins = await this.q()
|
|
|
|
.iterIndex(Stores.coins.exchangeBaseUrlIndex, exchangeInfo.baseUrl)
|
|
|
|
.indexJoinLeft(
|
|
|
|
Stores.denominations.exchangeBaseUrlIndex,
|
|
|
|
e => e.exchangeBaseUrl,
|
|
|
|
)
|
|
|
|
.fold(
|
|
|
|
(
|
|
|
|
cd: JoinLeftResult<CoinRecord, DenominationRecord>,
|
|
|
|
suspendedCoins: CoinRecord[],
|
|
|
|
) => {
|
|
|
|
if (!cd.right || !cd.right.isOffered) {
|
|
|
|
return Array.prototype.concat(suspendedCoins, [cd.left]);
|
|
|
|
}
|
|
|
|
return Array.prototype.concat(suspendedCoins);
|
|
|
|
},
|
|
|
|
[],
|
|
|
|
);
|
2016-10-13 02:23:24 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const q = this.q();
|
2017-12-10 23:02:00 +01:00
|
|
|
resultSuspendedCoins.map((c: CoinRecord) => {
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("suspending coin", c);
|
2016-09-28 18:00:13 +02:00
|
|
|
c.suspended = true;
|
2016-10-18 01:16:31 +02:00
|
|
|
q.put(Stores.coins, c);
|
2017-12-12 16:39:55 +01:00
|
|
|
this.badge.showNotification();
|
2017-08-30 17:08:54 +02:00
|
|
|
this.notifier.notify();
|
2016-09-28 18:00:13 +02:00
|
|
|
});
|
|
|
|
await q.finish();
|
|
|
|
}
|
2016-02-18 22:50:17 +01:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
private async updateExchangeFromJson(
|
|
|
|
baseUrl: string,
|
|
|
|
exchangeKeysJson: KeysJson,
|
|
|
|
wireMethodDetails: ExchangeWireJson,
|
|
|
|
): Promise<ExchangeRecord> {
|
2017-04-27 03:09:29 +02:00
|
|
|
// FIXME: all this should probably be commited atomically
|
2016-09-12 17:41:12 +02:00
|
|
|
const updateTimeSec = getTalerStampSec(exchangeKeysJson.list_issue_date);
|
|
|
|
if (updateTimeSec === null) {
|
2016-05-24 17:30:27 +02:00
|
|
|
throw Error("invalid update time");
|
|
|
|
}
|
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
if (exchangeKeysJson.denoms.length === 0) {
|
2017-04-28 23:28:27 +02:00
|
|
|
throw Error("exchange doesn't offer any denominations");
|
|
|
|
}
|
|
|
|
|
2016-11-16 01:59:39 +01:00
|
|
|
const r = await this.q().get<ExchangeRecord>(Stores.exchanges, baseUrl);
|
2016-09-28 18:00:13 +02:00
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
let exchangeInfo: ExchangeRecord;
|
2016-09-28 18:00:13 +02:00
|
|
|
|
|
|
|
if (!r) {
|
|
|
|
exchangeInfo = {
|
2017-05-28 01:10:54 +02:00
|
|
|
auditors: exchangeKeysJson.auditors,
|
2016-09-28 18:00:13 +02:00
|
|
|
baseUrl,
|
2019-06-26 15:30:32 +02:00
|
|
|
currency: Amounts.parseOrThrow(exchangeKeysJson.denoms[0].value)
|
|
|
|
.currency,
|
2016-11-16 01:59:39 +01:00
|
|
|
lastUpdateTime: updateTimeSec,
|
2017-12-10 21:34:56 +01:00
|
|
|
lastUsedTime: 0,
|
2016-09-28 18:00:13 +02:00
|
|
|
masterPublicKey: exchangeKeysJson.master_public_key,
|
|
|
|
};
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("making fresh exchange");
|
2016-09-28 18:00:13 +02:00
|
|
|
} else {
|
2016-11-16 01:59:39 +01:00
|
|
|
if (updateTimeSec < r.lastUpdateTime) {
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("outdated /keys, not updating");
|
2017-05-28 01:10:54 +02:00
|
|
|
return r;
|
2016-05-24 17:30:27 +02:00
|
|
|
}
|
2016-09-28 18:00:13 +02:00
|
|
|
exchangeInfo = r;
|
2016-11-16 01:59:39 +01:00
|
|
|
exchangeInfo.lastUpdateTime = updateTimeSec;
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("updating old exchange");
|
2016-09-28 18:00:13 +02:00
|
|
|
}
|
2016-05-24 17:30:27 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const updatedExchangeInfo = await this.updateExchangeInfo(
|
|
|
|
exchangeInfo,
|
|
|
|
exchangeKeysJson,
|
|
|
|
);
|
2016-09-28 18:00:13 +02:00
|
|
|
await this.suspendCoins(updatedExchangeInfo);
|
2017-06-04 20:16:09 +02:00
|
|
|
updatedExchangeInfo.protocolVersion = exchangeKeysJson.version;
|
2016-09-28 18:00:13 +02:00
|
|
|
|
2016-10-13 02:23:24 +02:00
|
|
|
await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.put(Stores.exchanges, updatedExchangeInfo)
|
|
|
|
.finish();
|
2016-09-28 18:00:13 +02:00
|
|
|
|
2017-04-27 03:09:29 +02:00
|
|
|
let oldWireFees = await this.q().get(Stores.exchangeWireFees, baseUrl);
|
|
|
|
if (!oldWireFees) {
|
|
|
|
oldWireFees = {
|
|
|
|
exchangeBaseUrl: baseUrl,
|
|
|
|
feesForType: {},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-05-08 04:53:26 +02:00
|
|
|
for (const paytoTargetType in wireMethodDetails.fees) {
|
2017-04-27 03:09:29 +02:00
|
|
|
let latestFeeStamp = 0;
|
2019-05-08 04:53:26 +02:00
|
|
|
const newFeeDetails = wireMethodDetails.fees[paytoTargetType];
|
|
|
|
const oldFeeDetails = oldWireFees.feesForType[paytoTargetType] || [];
|
|
|
|
oldWireFees.feesForType[paytoTargetType] = oldFeeDetails;
|
|
|
|
for (const oldFee of oldFeeDetails) {
|
2017-04-27 03:09:29 +02:00
|
|
|
if (oldFee.endStamp > latestFeeStamp) {
|
|
|
|
latestFeeStamp = oldFee.endStamp;
|
|
|
|
}
|
|
|
|
}
|
2019-05-08 04:53:26 +02:00
|
|
|
for (const fee of newFeeDetails) {
|
2017-05-28 01:10:54 +02:00
|
|
|
const start = getTalerStampSec(fee.start_date);
|
|
|
|
if (start === null) {
|
2017-04-27 03:09:29 +02:00
|
|
|
console.error("invalid start stamp in fee", fee);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (start < latestFeeStamp) {
|
|
|
|
continue;
|
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
const end = getTalerStampSec(fee.end_date);
|
|
|
|
if (end === null) {
|
2017-04-27 03:09:29 +02:00
|
|
|
console.error("invalid end stamp in fee", fee);
|
|
|
|
continue;
|
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
const wf: WireFee = {
|
2018-01-29 22:58:47 +01:00
|
|
|
closingFee: Amounts.parseOrThrow(fee.closing_fee),
|
2017-05-28 01:10:54 +02:00
|
|
|
endStamp: end,
|
2017-04-27 03:09:29 +02:00
|
|
|
sig: fee.sig,
|
|
|
|
startStamp: start,
|
2018-01-29 22:58:47 +01:00
|
|
|
wireFee: Amounts.parseOrThrow(fee.wire_fee),
|
2017-05-28 01:10:54 +02:00
|
|
|
};
|
2019-06-26 15:30:32 +02:00
|
|
|
const valid: boolean = await this.cryptoApi.isValidWireFee(
|
|
|
|
paytoTargetType,
|
|
|
|
wf,
|
|
|
|
exchangeInfo.masterPublicKey,
|
|
|
|
);
|
2017-04-27 03:09:29 +02:00
|
|
|
if (!valid) {
|
|
|
|
console.error("fee signature invalid", fee);
|
2017-04-27 04:06:48 +02:00
|
|
|
throw Error("fee signature invalid");
|
2017-04-27 03:09:29 +02:00
|
|
|
}
|
2019-05-08 04:53:26 +02:00
|
|
|
oldFeeDetails.push(wf);
|
2017-04-27 03:09:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
await this.q().put(Stores.exchangeWireFees, oldWireFees);
|
|
|
|
|
2017-05-01 04:05:16 +02:00
|
|
|
if (exchangeKeysJson.payback) {
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const payback of exchangeKeysJson.payback) {
|
2019-06-26 15:30:32 +02:00
|
|
|
const denom = await this.q().getIndexed(
|
|
|
|
Stores.denominations.denomPubHashIndex,
|
|
|
|
payback.h_denom_pub,
|
|
|
|
);
|
2017-05-01 04:05:16 +02:00
|
|
|
if (!denom) {
|
|
|
|
continue;
|
|
|
|
}
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log(`cashing back denom`, denom);
|
2019-06-26 15:30:32 +02:00
|
|
|
const coins = await this.q()
|
|
|
|
.iterIndex(Stores.coins.denomPubIndex, denom.denomPub)
|
|
|
|
.toArray();
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const coin of coins) {
|
2017-05-01 04:05:16 +02:00
|
|
|
this.payback(coin.coinPub);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-28 18:00:13 +02:00
|
|
|
return updatedExchangeInfo;
|
2016-05-24 17:30:27 +02:00
|
|
|
}
|
2016-02-18 22:50:17 +01:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
private async updateExchangeInfo(
|
|
|
|
exchangeInfo: ExchangeRecord,
|
|
|
|
newKeys: KeysJson,
|
|
|
|
): Promise<ExchangeRecord> {
|
2017-05-28 01:10:54 +02:00
|
|
|
if (exchangeInfo.masterPublicKey !== newKeys.master_public_key) {
|
2016-05-24 17:30:27 +02:00
|
|
|
throw Error("public keys do not match");
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const existingDenoms: {
|
|
|
|
[denomPub: string]: DenominationRecord;
|
|
|
|
} = await this.q()
|
|
|
|
.iterIndex(
|
|
|
|
Stores.denominations.exchangeBaseUrlIndex,
|
|
|
|
exchangeInfo.baseUrl,
|
|
|
|
)
|
|
|
|
.fold(
|
|
|
|
(x: DenominationRecord, acc: typeof existingDenoms) => (
|
|
|
|
(acc[x.denomPub] = x), acc
|
|
|
|
),
|
|
|
|
{},
|
|
|
|
);
|
2016-05-24 17:30:27 +02:00
|
|
|
|
2016-11-16 01:59:39 +01:00
|
|
|
const newDenoms: typeof existingDenoms = {};
|
2016-11-20 04:15:49 +01:00
|
|
|
const newAndUnseenDenoms: typeof existingDenoms = {};
|
2016-05-24 17:30:27 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const d of newKeys.denoms) {
|
|
|
|
const dr = await this.denominationRecordFromKeys(exchangeInfo.baseUrl, d);
|
2016-11-16 01:59:39 +01:00
|
|
|
if (!(d.denom_pub in existingDenoms)) {
|
2016-11-20 04:15:49 +01:00
|
|
|
newAndUnseenDenoms[dr.denomPub] = dr;
|
2016-09-28 19:09:10 +02:00
|
|
|
}
|
2016-11-20 04:15:49 +01:00
|
|
|
newDenoms[dr.denomPub] = dr;
|
2016-11-16 01:59:39 +01:00
|
|
|
}
|
2016-05-24 17:30:27 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
for (const oldDenomPub in existingDenoms) {
|
2016-11-16 01:59:39 +01:00
|
|
|
if (!(oldDenomPub in newDenoms)) {
|
2017-05-28 01:10:54 +02:00
|
|
|
const d = existingDenoms[oldDenomPub];
|
2016-11-16 01:59:39 +01:00
|
|
|
d.isOffered = false;
|
|
|
|
}
|
|
|
|
}
|
2016-09-28 19:09:10 +02:00
|
|
|
|
2016-11-16 01:59:39 +01:00
|
|
|
await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.putAll(
|
|
|
|
Stores.denominations,
|
|
|
|
Object.keys(newAndUnseenDenoms).map(d => newAndUnseenDenoms[d]),
|
|
|
|
)
|
|
|
|
.putAll(
|
|
|
|
Stores.denominations,
|
|
|
|
Object.keys(existingDenoms).map(d => existingDenoms[d]),
|
|
|
|
)
|
|
|
|
.finish();
|
2016-09-28 19:09:10 +02:00
|
|
|
return exchangeInfo;
|
2016-01-06 15:39:22 +01:00
|
|
|
}
|
2016-01-05 01:10:31 +01:00
|
|
|
|
2016-02-11 18:17:02 +01:00
|
|
|
/**
|
2017-08-14 04:16:12 +02:00
|
|
|
* Get detailed balance information, sliced by exchange and by currency.
|
2016-02-11 18:17:02 +01:00
|
|
|
*/
|
2016-10-19 18:40:29 +02:00
|
|
|
async getBalances(): Promise<WalletBalance> {
|
2017-08-14 04:16:12 +02:00
|
|
|
/**
|
|
|
|
* Add amount to a balance field, both for
|
|
|
|
* the slicing by exchange and currency.
|
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
function addTo(
|
|
|
|
balance: WalletBalance,
|
|
|
|
field: keyof WalletBalanceEntry,
|
|
|
|
amount: AmountJson,
|
|
|
|
exchange: string,
|
|
|
|
): void {
|
2017-08-14 04:16:12 +02:00
|
|
|
const z = Amounts.getZero(amount.currency);
|
2019-06-26 15:30:32 +02:00
|
|
|
const balanceIdentity = {
|
|
|
|
available: z,
|
|
|
|
paybackAmount: z,
|
|
|
|
pendingIncoming: z,
|
|
|
|
pendingPayment: z,
|
|
|
|
};
|
2017-08-14 04:16:12 +02:00
|
|
|
let entryCurr = balance.byCurrency[amount.currency];
|
|
|
|
if (!entryCurr) {
|
2019-06-26 15:30:32 +02:00
|
|
|
balance.byCurrency[amount.currency] = entryCurr = {
|
|
|
|
...balanceIdentity,
|
|
|
|
};
|
2017-08-14 04:16:12 +02:00
|
|
|
}
|
|
|
|
let entryEx = balance.byExchange[exchange];
|
|
|
|
if (!entryEx) {
|
|
|
|
balance.byExchange[exchange] = entryEx = { ...balanceIdentity };
|
2016-10-19 18:40:29 +02:00
|
|
|
}
|
2017-08-14 04:16:12 +02:00
|
|
|
entryCurr[field] = Amounts.add(entryCurr[field], amount).amount;
|
|
|
|
entryEx[field] = Amounts.add(entryEx[field], amount).amount;
|
2016-10-19 18:40:29 +02:00
|
|
|
}
|
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
function collectBalances(c: CoinRecord, balance: WalletBalance) {
|
2016-05-24 17:30:27 +02:00
|
|
|
if (c.suspended) {
|
2016-10-19 18:40:29 +02:00
|
|
|
return balance;
|
|
|
|
}
|
2017-08-30 17:08:54 +02:00
|
|
|
if (c.status === CoinStatus.Fresh) {
|
|
|
|
addTo(balance, "available", c.currentAmount, c.exchangeBaseUrl);
|
|
|
|
return balance;
|
|
|
|
}
|
|
|
|
if (c.status === CoinStatus.Dirty) {
|
|
|
|
addTo(balance, "pendingIncoming", c.currentAmount, c.exchangeBaseUrl);
|
2017-04-13 16:08:41 +02:00
|
|
|
return balance;
|
|
|
|
}
|
2016-10-19 18:40:29 +02:00
|
|
|
return balance;
|
|
|
|
}
|
|
|
|
|
|
|
|
function collectPendingWithdraw(r: ReserveRecord, balance: WalletBalance) {
|
2017-10-15 18:30:02 +02:00
|
|
|
if (!r.timestamp_confirmed) {
|
2016-10-19 18:40:29 +02:00
|
|
|
return balance;
|
2016-05-24 17:30:27 +02:00
|
|
|
}
|
2019-09-01 22:59:48 +02:00
|
|
|
let amount = Amounts.getZero(r.requested_amount.currency);
|
|
|
|
/*
|
2016-10-19 18:40:29 +02:00
|
|
|
let amount = r.current_amount;
|
|
|
|
if (!amount) {
|
|
|
|
amount = r.requested_amount;
|
2016-01-06 15:39:22 +01:00
|
|
|
}
|
2019-09-01 22:59:48 +02:00
|
|
|
*/
|
2016-10-20 01:37:00 +02:00
|
|
|
amount = Amounts.add(amount, r.precoin_amount).amount;
|
2016-10-19 18:40:29 +02:00
|
|
|
if (Amounts.cmp(smallestWithdraw[r.exchange_base_url], amount) < 0) {
|
2017-08-14 04:16:12 +02:00
|
|
|
addTo(balance, "pendingIncoming", amount, r.exchange_base_url);
|
2016-10-19 18:40:29 +02:00
|
|
|
}
|
|
|
|
return balance;
|
2016-01-05 01:10:31 +01:00
|
|
|
}
|
2015-12-13 23:47:30 +01:00
|
|
|
|
2017-05-01 04:05:16 +02:00
|
|
|
function collectPaybacks(r: ReserveRecord, balance: WalletBalance) {
|
|
|
|
if (!r.hasPayback) {
|
|
|
|
return balance;
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
if (
|
|
|
|
Amounts.cmp(smallestWithdraw[r.exchange_base_url], r.current_amount!) <
|
|
|
|
0
|
|
|
|
) {
|
2017-08-14 04:16:12 +02:00
|
|
|
addTo(balance, "paybackAmount", r.current_amount!, r.exchange_base_url);
|
2017-05-01 04:05:16 +02:00
|
|
|
}
|
|
|
|
return balance;
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
function collectPendingRefresh(
|
|
|
|
r: RefreshSessionRecord,
|
|
|
|
balance: WalletBalance,
|
|
|
|
) {
|
2017-03-10 15:27:36 +01:00
|
|
|
// Don't count finished refreshes, since the refresh already resulted
|
|
|
|
// in coins being added to the wallet.
|
2017-03-10 15:25:54 +01:00
|
|
|
if (r.finished) {
|
2016-10-19 18:40:29 +02:00
|
|
|
return balance;
|
|
|
|
}
|
2017-08-14 04:16:12 +02:00
|
|
|
addTo(balance, "pendingIncoming", r.valueOutput, r.exchangeBaseUrl);
|
2016-10-19 18:40:29 +02:00
|
|
|
|
|
|
|
return balance;
|
|
|
|
}
|
|
|
|
|
2017-08-27 03:56:19 +02:00
|
|
|
function collectPayments(t: PurchaseRecord, balance: WalletBalance) {
|
2016-10-19 22:49:03 +02:00
|
|
|
if (t.finished) {
|
|
|
|
return balance;
|
|
|
|
}
|
2018-01-04 13:22:23 +01:00
|
|
|
for (const c of t.payReq.coins) {
|
2019-06-26 15:30:32 +02:00
|
|
|
addTo(
|
|
|
|
balance,
|
|
|
|
"pendingPayment",
|
|
|
|
Amounts.parseOrThrow(c.contribution),
|
|
|
|
c.exchange_url,
|
|
|
|
);
|
2018-01-04 13:22:23 +01:00
|
|
|
}
|
2016-10-19 22:49:03 +02:00
|
|
|
return balance;
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
function collectSmallestWithdraw(
|
|
|
|
e: JoinResult<ExchangeRecord, DenominationRecord>,
|
|
|
|
sw: any,
|
|
|
|
) {
|
2016-11-16 01:59:39 +01:00
|
|
|
let min = sw[e.left.baseUrl];
|
2017-05-28 01:10:54 +02:00
|
|
|
const v = Amounts.add(e.right.value, e.right.feeWithdraw).amount;
|
2016-11-16 01:59:39 +01:00
|
|
|
if (!min) {
|
|
|
|
min = v;
|
|
|
|
} else if (Amounts.cmp(v, min) < 0) {
|
|
|
|
min = v;
|
2016-10-19 18:40:29 +02:00
|
|
|
}
|
2016-11-16 01:59:39 +01:00
|
|
|
sw[e.left.baseUrl] = min;
|
2016-10-19 18:40:29 +02:00
|
|
|
return sw;
|
|
|
|
}
|
|
|
|
|
2017-10-15 19:28:35 +02:00
|
|
|
const balanceStore = {
|
2017-08-14 04:16:12 +02:00
|
|
|
byCurrency: {},
|
2017-10-15 19:28:35 +02:00
|
|
|
byExchange: {},
|
2017-08-14 04:16:12 +02:00
|
|
|
};
|
2016-10-19 18:40:29 +02:00
|
|
|
// Mapping from exchange pub to smallest
|
|
|
|
// possible amount we can withdraw
|
2019-06-26 15:30:32 +02:00
|
|
|
let smallestWithdraw: { [baseUrl: string]: AmountJson } = {};
|
2016-10-19 18:40:29 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
smallestWithdraw = await this.q()
|
|
|
|
.iter(Stores.exchanges)
|
|
|
|
.indexJoin(Stores.denominations.exchangeBaseUrlIndex, x => x.baseUrl)
|
|
|
|
.fold(collectSmallestWithdraw, {});
|
2016-10-19 18:40:29 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const tx = this.q();
|
2019-06-26 15:30:32 +02:00
|
|
|
tx.iter(Stores.coins).fold(collectBalances, balanceStore);
|
|
|
|
tx.iter(Stores.refresh).fold(collectPendingRefresh, balanceStore);
|
|
|
|
tx.iter(Stores.reserves).fold(collectPendingWithdraw, balanceStore);
|
|
|
|
tx.iter(Stores.reserves).fold(collectPaybacks, balanceStore);
|
|
|
|
tx.iter(Stores.purchases).fold(collectPayments, balanceStore);
|
2016-10-19 23:40:45 +02:00
|
|
|
await tx.finish();
|
2017-10-15 19:28:35 +02:00
|
|
|
return balanceStore;
|
2016-10-13 02:23:24 +02:00
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
async createRefreshSession(
|
|
|
|
oldCoinPub: string,
|
|
|
|
): Promise<RefreshSessionRecord | undefined> {
|
2017-05-28 01:10:54 +02:00
|
|
|
const coin = await this.q().get<CoinRecord>(Stores.coins, oldCoinPub);
|
2016-10-13 02:23:24 +02:00
|
|
|
|
|
|
|
if (!coin) {
|
2016-10-17 23:49:04 +02:00
|
|
|
throw Error("coin not found");
|
2016-10-13 02:23:24 +02:00
|
|
|
}
|
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
if (coin.currentAmount.value === 0 && coin.currentAmount.fraction === 0) {
|
2017-04-13 15:05:38 +02:00
|
|
|
return undefined;
|
|
|
|
}
|
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const exchange = await this.updateExchangeFromUrl(coin.exchangeBaseUrl);
|
2016-10-18 02:11:41 +02:00
|
|
|
|
2016-10-13 02:23:24 +02:00
|
|
|
if (!exchange) {
|
|
|
|
throw Error("db inconsistent");
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const oldDenom = await this.q().get(Stores.denominations, [
|
|
|
|
exchange.baseUrl,
|
|
|
|
coin.denomPub,
|
|
|
|
]);
|
2016-10-13 02:23:24 +02:00
|
|
|
|
|
|
|
if (!oldDenom) {
|
|
|
|
throw Error("db inconsistent");
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const availableDenoms: DenominationRecord[] = await this.q()
|
|
|
|
.iterIndex(Stores.denominations.exchangeBaseUrlIndex, exchange.baseUrl)
|
|
|
|
.toArray();
|
2016-10-13 02:23:24 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const availableAmount = Amounts.sub(coin.currentAmount, oldDenom.feeRefresh)
|
|
|
|
.amount;
|
2016-10-14 02:13:06 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const newCoinDenoms = getWithdrawDenomList(
|
|
|
|
availableAmount,
|
|
|
|
availableDenoms,
|
|
|
|
);
|
2016-10-13 02:23:24 +02:00
|
|
|
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("refreshing coin", coin);
|
|
|
|
Wallet.enableTracing && console.log("refreshing into", newCoinDenoms);
|
2016-10-13 02:23:24 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
if (newCoinDenoms.length === 0) {
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.log(
|
|
|
|
`not refreshing, available amount ${amountToPretty(
|
|
|
|
availableAmount,
|
|
|
|
)} too small`,
|
|
|
|
);
|
2017-08-30 17:08:54 +02:00
|
|
|
coin.status = CoinStatus.Useless;
|
|
|
|
await this.q().put(Stores.coins, coin);
|
|
|
|
this.notifier.notify();
|
2016-10-17 23:49:04 +02:00
|
|
|
return undefined;
|
2016-10-17 15:58:36 +02:00
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const refreshSession: RefreshSessionRecord = await this.cryptoApi.createRefreshSession(
|
|
|
|
exchange.baseUrl,
|
|
|
|
3,
|
|
|
|
coin,
|
|
|
|
newCoinDenoms,
|
|
|
|
oldDenom.feeRefresh,
|
|
|
|
);
|
2016-10-17 15:58:36 +02:00
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
function mutateCoin(c: CoinRecord): CoinRecord {
|
2019-06-26 15:30:32 +02:00
|
|
|
const r = Amounts.sub(c.currentAmount, refreshSession.valueWithFee);
|
2016-10-19 23:55:58 +02:00
|
|
|
if (r.saturated) {
|
|
|
|
// Something else must have written the coin value
|
|
|
|
throw AbortTransaction;
|
|
|
|
}
|
|
|
|
c.currentAmount = r.amount;
|
2017-04-13 16:08:41 +02:00
|
|
|
c.status = CoinStatus.Refreshed;
|
2016-10-19 23:55:58 +02:00
|
|
|
return c;
|
|
|
|
}
|
2016-10-17 15:58:36 +02:00
|
|
|
|
2017-04-13 15:05:38 +02:00
|
|
|
// Store refresh session and subtract refreshed amount from
|
|
|
|
// coin in the same transaction.
|
2017-08-27 05:42:46 +02:00
|
|
|
const query = this.q();
|
2019-06-26 15:30:32 +02:00
|
|
|
query
|
|
|
|
.put(Stores.refresh, refreshSession, "refreshKey")
|
|
|
|
.mutate(Stores.coins, coin.coinPub, mutateCoin);
|
2017-08-27 05:42:46 +02:00
|
|
|
await query.finish();
|
2017-08-30 17:08:54 +02:00
|
|
|
this.notifier.notify();
|
2017-08-27 05:42:46 +02:00
|
|
|
|
|
|
|
const key = query.key("refreshKey");
|
|
|
|
if (!key || typeof key !== "number") {
|
|
|
|
throw Error("insert failed");
|
|
|
|
}
|
|
|
|
|
|
|
|
refreshSession.id = key;
|
2016-10-17 15:58:36 +02:00
|
|
|
|
2016-10-17 23:49:04 +02:00
|
|
|
return refreshSession;
|
|
|
|
}
|
2016-10-13 02:23:24 +02:00
|
|
|
|
2016-10-17 23:49:04 +02:00
|
|
|
async refresh(oldCoinPub: string): Promise<void> {
|
2019-09-04 15:28:19 +02:00
|
|
|
const refreshImpl = async () => {
|
|
|
|
const oldRefreshSessions = await this.q()
|
|
|
|
.iter(Stores.refresh)
|
|
|
|
.toArray();
|
|
|
|
for (const session of oldRefreshSessions) {
|
|
|
|
Wallet.enableTracing &&
|
|
|
|
console.log("got old refresh session for", oldCoinPub, session);
|
|
|
|
return this.continueRefreshSession(session);
|
|
|
|
}
|
|
|
|
const coin = await this.q().get(Stores.coins, oldCoinPub);
|
|
|
|
if (!coin) {
|
|
|
|
console.warn("can't refresh, coin not in database");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (
|
|
|
|
coin.status === CoinStatus.Useless ||
|
|
|
|
coin.status === CoinStatus.Fresh
|
|
|
|
) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const refreshSession = await this.createRefreshSession(oldCoinPub);
|
|
|
|
if (!refreshSession) {
|
|
|
|
// refreshing not necessary
|
|
|
|
Wallet.enableTracing && console.log("not refreshing", oldCoinPub);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
return this.continueRefreshSession(refreshSession);
|
|
|
|
};
|
|
|
|
|
|
|
|
const activeRefreshOp = this.activeRefreshOperations[oldCoinPub];
|
|
|
|
|
|
|
|
if (activeRefreshOp) {
|
|
|
|
return activeRefreshOp;
|
2017-08-30 17:08:54 +02:00
|
|
|
}
|
2019-09-04 15:28:19 +02:00
|
|
|
|
|
|
|
try {
|
|
|
|
const newOp = refreshImpl();
|
|
|
|
this.activeRefreshOperations[oldCoinPub] = newOp;
|
|
|
|
const res = await newOp;
|
|
|
|
return res;
|
|
|
|
} finally {
|
|
|
|
delete this.activeRefreshOperations[oldCoinPub];
|
2016-10-17 23:49:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
async continueRefreshSession(refreshSession: RefreshSessionRecord) {
|
2016-10-17 23:49:04 +02:00
|
|
|
if (refreshSession.finished) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (typeof refreshSession.norevealIndex !== "number") {
|
|
|
|
await this.refreshMelt(refreshSession);
|
2019-06-26 15:30:32 +02:00
|
|
|
const r = await this.q().get<RefreshSessionRecord>(
|
|
|
|
Stores.refresh,
|
|
|
|
refreshSession.id,
|
|
|
|
);
|
2016-10-17 23:49:04 +02:00
|
|
|
if (!r) {
|
|
|
|
throw Error("refresh session does not exist anymore");
|
|
|
|
}
|
|
|
|
refreshSession = r;
|
|
|
|
}
|
|
|
|
|
|
|
|
await this.refreshReveal(refreshSession);
|
2016-10-17 15:58:36 +02:00
|
|
|
}
|
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
async refreshMelt(refreshSession: RefreshSessionRecord): Promise<void> {
|
2017-05-28 01:10:54 +02:00
|
|
|
if (refreshSession.norevealIndex !== undefined) {
|
2016-10-17 15:58:36 +02:00
|
|
|
console.error("won't melt again");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const coin = await this.q().get<CoinRecord>(
|
|
|
|
Stores.coins,
|
|
|
|
refreshSession.meltCoinPub,
|
|
|
|
);
|
2016-10-17 15:58:36 +02:00
|
|
|
if (!coin) {
|
|
|
|
console.error("can't melt coin, it does not exist");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const reqUrl = new URI("refresh/melt").absoluteTo(
|
|
|
|
refreshSession.exchangeBaseUrl,
|
|
|
|
);
|
2017-12-09 03:37:21 +01:00
|
|
|
const meltReq = {
|
2016-10-14 02:13:06 +02:00
|
|
|
coin_pub: coin.coinPub,
|
2017-05-28 01:10:54 +02:00
|
|
|
confirm_sig: refreshSession.confirmSig,
|
2019-05-08 07:01:17 +02:00
|
|
|
denom_pub_hash: coin.denomPubHash,
|
2016-10-14 02:13:06 +02:00
|
|
|
denom_sig: coin.denomSig,
|
2017-12-09 03:37:21 +01:00
|
|
|
rc: refreshSession.hash,
|
2016-10-14 02:13:06 +02:00
|
|
|
value_with_fee: refreshSession.valueWithFee,
|
|
|
|
};
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("melt request:", meltReq);
|
2017-12-09 03:37:21 +01:00
|
|
|
const resp = await this.http.postJson(reqUrl.href(), meltReq);
|
2016-10-13 02:36:33 +02:00
|
|
|
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("melt response:", resp.responseJson);
|
2016-09-28 18:00:13 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
if (resp.status !== 200) {
|
2019-07-31 01:33:56 +02:00
|
|
|
console.error(resp.responseJson);
|
2016-10-14 02:13:06 +02:00
|
|
|
throw Error("refresh failed");
|
|
|
|
}
|
|
|
|
|
2019-07-31 01:33:56 +02:00
|
|
|
const respJson = resp.responseJson;
|
2016-10-14 02:13:06 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const norevealIndex = respJson.noreveal_index;
|
2016-10-14 02:13:06 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
if (typeof norevealIndex !== "number") {
|
2016-10-14 02:13:06 +02:00
|
|
|
throw Error("invalid response");
|
|
|
|
}
|
|
|
|
|
|
|
|
refreshSession.norevealIndex = norevealIndex;
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.put(Stores.refresh, refreshSession)
|
|
|
|
.finish();
|
2017-08-30 17:08:54 +02:00
|
|
|
this.notifier.notify();
|
2016-01-05 01:10:31 +01:00
|
|
|
}
|
2016-01-24 02:29:13 +01:00
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
async refreshReveal(refreshSession: RefreshSessionRecord): Promise<void> {
|
2017-05-28 01:10:54 +02:00
|
|
|
const norevealIndex = refreshSession.norevealIndex;
|
|
|
|
if (norevealIndex === undefined) {
|
2016-10-14 02:13:06 +02:00
|
|
|
throw Error("can't reveal without melting first");
|
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
const privs = Array.from(refreshSession.transferPrivs);
|
2016-10-14 02:13:06 +02:00
|
|
|
privs.splice(norevealIndex, 1);
|
|
|
|
|
2017-12-09 03:37:21 +01:00
|
|
|
const preCoins = refreshSession.preCoinsForGammas[norevealIndex];
|
|
|
|
if (!preCoins) {
|
|
|
|
throw Error("refresh index error");
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const meltCoinRecord = await this.q().get(
|
|
|
|
Stores.coins,
|
|
|
|
refreshSession.meltCoinPub,
|
|
|
|
);
|
|
|
|
if (!meltCoinRecord) {
|
|
|
|
throw Error("inconsistent database");
|
|
|
|
}
|
|
|
|
|
2017-12-09 03:37:21 +01:00
|
|
|
const evs = preCoins.map((x: RefreshPreCoinRecord) => x.coinEv);
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
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],
|
|
|
|
preCoins[i].coinEv,
|
|
|
|
);
|
|
|
|
linkSigs.push(linkSig);
|
|
|
|
}
|
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const req = {
|
2017-12-09 03:37:21 +01:00
|
|
|
coin_evs: evs,
|
|
|
|
new_denoms_h: refreshSession.newDenomHashes,
|
|
|
|
rc: refreshSession.hash,
|
2017-05-28 01:10:54 +02:00
|
|
|
transfer_privs: privs,
|
2017-12-09 03:37:21 +01:00
|
|
|
transfer_pub: refreshSession.transferPubs[norevealIndex],
|
2019-06-26 15:30:32 +02:00
|
|
|
link_sigs: linkSigs,
|
2016-10-14 02:13:06 +02:00
|
|
|
};
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const reqUrl = new URI("refresh/reveal").absoluteTo(
|
|
|
|
refreshSession.exchangeBaseUrl,
|
|
|
|
);
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("reveal request:", req);
|
2019-08-28 02:49:27 +02:00
|
|
|
|
|
|
|
let resp;
|
|
|
|
try {
|
|
|
|
resp = await this.http.postJson(reqUrl.href(), req);
|
|
|
|
} catch (e) {
|
|
|
|
console.error("got error during /refresh/reveal request");
|
|
|
|
return;
|
|
|
|
}
|
2016-10-14 02:13:06 +02:00
|
|
|
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("session:", refreshSession);
|
|
|
|
Wallet.enableTracing && console.log("reveal response:", resp);
|
2016-10-17 15:58:36 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
if (resp.status !== 200) {
|
2019-08-26 01:39:13 +02:00
|
|
|
console.error("error: /refresh/reveal returned status " + resp.status);
|
2016-10-17 15:58:36 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-07-31 01:33:56 +02:00
|
|
|
const respJson = resp.responseJson;
|
2016-10-17 15:58:36 +02:00
|
|
|
|
|
|
|
if (!respJson.ev_sigs || !Array.isArray(respJson.ev_sigs)) {
|
2019-08-26 01:39:13 +02:00
|
|
|
console.error("/refresh/reveal did not contain ev_sigs");
|
|
|
|
return;
|
2016-10-17 15:58:36 +02:00
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const exchange = await this.q().get<ExchangeRecord>(
|
|
|
|
Stores.exchanges,
|
|
|
|
refreshSession.exchangeBaseUrl,
|
|
|
|
);
|
2016-10-17 15:58:36 +02:00
|
|
|
if (!exchange) {
|
|
|
|
console.error(`exchange ${refreshSession.exchangeBaseUrl} not found`);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
const coins: CoinRecord[] = [];
|
2016-10-17 23:49:04 +02:00
|
|
|
|
2016-10-17 15:58:36 +02:00
|
|
|
for (let i = 0; i < respJson.ev_sigs.length; i++) {
|
2019-06-26 15:30:32 +02:00
|
|
|
const denom = await this.q().get(Stores.denominations, [
|
|
|
|
refreshSession.exchangeBaseUrl,
|
|
|
|
refreshSession.newDenoms[i],
|
|
|
|
]);
|
2016-10-17 15:58:36 +02:00
|
|
|
if (!denom) {
|
|
|
|
console.error("denom not found");
|
|
|
|
continue;
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
const pc =
|
|
|
|
refreshSession.preCoinsForGammas[refreshSession.norevealIndex!][i];
|
|
|
|
const denomSig = await this.cryptoApi.rsaUnblind(
|
|
|
|
respJson.ev_sigs[i].ev_sig,
|
|
|
|
pc.blindingKey,
|
|
|
|
denom.denomPub,
|
|
|
|
);
|
2017-05-28 01:10:54 +02:00
|
|
|
const coin: CoinRecord = {
|
2017-05-01 04:33:47 +02:00
|
|
|
blindingKey: pc.blindingKey,
|
2016-10-17 15:58:36 +02:00
|
|
|
coinPriv: pc.privateKey,
|
2017-05-28 01:10:54 +02:00
|
|
|
coinPub: pc.publicKey,
|
2016-10-17 15:58:36 +02:00
|
|
|
currentAmount: denom.value,
|
2017-05-28 01:10:54 +02:00
|
|
|
denomPub: denom.denomPub,
|
2019-05-08 07:01:17 +02:00
|
|
|
denomPubHash: denom.denomPubHash,
|
2017-05-28 01:10:54 +02:00
|
|
|
denomSig,
|
2016-10-17 15:58:36 +02:00
|
|
|
exchangeBaseUrl: refreshSession.exchangeBaseUrl,
|
2017-05-28 01:10:54 +02:00
|
|
|
reservePub: undefined,
|
2017-04-13 16:08:41 +02:00
|
|
|
status: CoinStatus.Fresh,
|
2016-10-17 15:58:36 +02:00
|
|
|
};
|
|
|
|
|
2016-10-17 23:49:04 +02:00
|
|
|
coins.push(coin);
|
2016-10-17 15:58:36 +02:00
|
|
|
}
|
2016-10-17 23:49:04 +02:00
|
|
|
|
|
|
|
refreshSession.finished = true;
|
|
|
|
|
|
|
|
await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.putAll(Stores.coins, coins)
|
|
|
|
.put(Stores.refresh, refreshSession)
|
|
|
|
.finish();
|
2017-08-30 17:08:54 +02:00
|
|
|
this.notifier.notify();
|
2016-10-14 02:13:06 +02:00
|
|
|
}
|
|
|
|
|
2016-02-11 18:17:02 +01:00
|
|
|
/**
|
|
|
|
* Retrive the full event history for this wallet.
|
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
async getHistory(): Promise<{ history: HistoryRecord[] }> {
|
2017-10-15 18:30:02 +02:00
|
|
|
const history: HistoryRecord[] = [];
|
|
|
|
|
|
|
|
// FIXME: do pagination instead of generating the full history
|
|
|
|
|
2019-08-22 23:36:36 +02:00
|
|
|
// We uniquely identify history rows via their timestamp.
|
|
|
|
// This works as timestamps are guaranteed to be monotonically
|
2019-08-24 18:42:00 +02:00
|
|
|
// increasing even
|
2019-08-22 23:36:36 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const proposals = await this.q()
|
|
|
|
.iter<ProposalDownloadRecord>(Stores.proposals)
|
|
|
|
.toArray();
|
2017-10-15 19:28:35 +02:00
|
|
|
for (const p of proposals) {
|
2017-10-15 18:30:02 +02:00
|
|
|
history.push({
|
|
|
|
detail: {
|
|
|
|
contractTermsHash: p.contractTermsHash,
|
|
|
|
merchantName: p.contractTerms.merchant.name,
|
|
|
|
},
|
2017-10-15 19:28:35 +02:00
|
|
|
timestamp: p.timestamp,
|
|
|
|
type: "offer-contract",
|
2017-10-15 18:30:02 +02:00
|
|
|
});
|
2016-01-24 02:29:13 +01:00
|
|
|
}
|
2016-01-26 17:21:17 +01:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const purchases = await this.q()
|
|
|
|
.iter<PurchaseRecord>(Stores.purchases)
|
|
|
|
.toArray();
|
2017-10-15 19:28:35 +02:00
|
|
|
for (const p of purchases) {
|
2017-10-15 18:30:02 +02:00
|
|
|
history.push({
|
|
|
|
detail: {
|
|
|
|
amount: p.contractTerms.amount,
|
|
|
|
contractTermsHash: p.contractTermsHash,
|
|
|
|
fulfillmentUrl: p.contractTerms.fulfillment_url,
|
|
|
|
merchantName: p.contractTerms.merchant.name,
|
|
|
|
},
|
2017-10-15 19:28:35 +02:00
|
|
|
timestamp: p.timestamp,
|
|
|
|
type: "pay",
|
2017-10-15 18:30:02 +02:00
|
|
|
});
|
|
|
|
if (p.timestamp_refund) {
|
2018-01-29 22:58:47 +01:00
|
|
|
const contractAmount = Amounts.parseOrThrow(p.contractTerms.amount);
|
2019-06-26 15:30:32 +02:00
|
|
|
const amountsPending = Object.keys(p.refundsPending).map(x =>
|
|
|
|
Amounts.parseOrThrow(p.refundsPending[x].refund_amount),
|
2018-01-29 22:58:47 +01:00
|
|
|
);
|
2019-06-26 15:30:32 +02:00
|
|
|
const amountsDone = Object.keys(p.refundsDone).map(x =>
|
|
|
|
Amounts.parseOrThrow(p.refundsDone[x].refund_amount),
|
2018-01-29 22:58:47 +01:00
|
|
|
);
|
2017-10-15 18:30:02 +02:00
|
|
|
const amounts: AmountJson[] = amountsPending.concat(amountsDone);
|
2019-06-26 15:30:32 +02:00
|
|
|
const amount = Amounts.add(
|
|
|
|
Amounts.getZero(contractAmount.currency),
|
|
|
|
...amounts,
|
|
|
|
).amount;
|
2017-10-15 18:30:02 +02:00
|
|
|
|
|
|
|
history.push({
|
|
|
|
detail: {
|
|
|
|
contractTermsHash: p.contractTermsHash,
|
|
|
|
fulfillmentUrl: p.contractTerms.fulfillment_url,
|
|
|
|
merchantName: p.contractTerms.merchant.name,
|
2017-10-15 19:28:35 +02:00
|
|
|
refundAmount: amount,
|
2017-10-15 18:30:02 +02:00
|
|
|
},
|
2017-10-15 19:28:35 +02:00
|
|
|
timestamp: p.timestamp_refund,
|
|
|
|
type: "refund",
|
2017-10-15 18:30:02 +02:00
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
2016-09-28 17:52:36 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const reserves: ReserveRecord[] = await this.q()
|
|
|
|
.iter<ReserveRecord>(Stores.reserves)
|
|
|
|
.toArray();
|
2017-10-15 19:28:35 +02:00
|
|
|
for (const r of reserves) {
|
2017-10-15 18:30:02 +02:00
|
|
|
history.push({
|
|
|
|
detail: {
|
|
|
|
exchangeBaseUrl: r.exchange_base_url,
|
|
|
|
requestedAmount: r.requested_amount,
|
|
|
|
reservePub: r.reserve_pub,
|
|
|
|
},
|
2017-10-15 19:28:35 +02:00
|
|
|
timestamp: r.created,
|
|
|
|
type: "create-reserve",
|
2017-10-15 18:30:02 +02:00
|
|
|
});
|
|
|
|
if (r.timestamp_depleted) {
|
|
|
|
history.push({
|
|
|
|
detail: {
|
|
|
|
exchangeBaseUrl: r.exchange_base_url,
|
|
|
|
requestedAmount: r.requested_amount,
|
|
|
|
reservePub: r.reserve_pub,
|
|
|
|
},
|
2017-10-15 19:28:35 +02:00
|
|
|
timestamp: r.timestamp_depleted,
|
|
|
|
type: "depleted-reserve",
|
2017-10-15 18:30:02 +02:00
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const tips: TipRecord[] = await this.q()
|
|
|
|
.iter<TipRecord>(Stores.tips)
|
|
|
|
.toArray();
|
2017-12-12 15:38:03 +01:00
|
|
|
for (const tip of tips) {
|
|
|
|
history.push({
|
|
|
|
detail: {
|
2017-12-12 16:51:13 +01:00
|
|
|
accepted: tip.accepted,
|
2018-01-03 14:42:06 +01:00
|
|
|
amount: tip.amount,
|
|
|
|
merchantDomain: tip.merchantDomain,
|
2017-12-12 15:38:03 +01:00
|
|
|
tipId: tip.tipId,
|
|
|
|
},
|
|
|
|
timestamp: tip.timestamp,
|
|
|
|
type: "tip",
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-10-15 18:30:02 +02:00
|
|
|
history.sort((h1, h2) => Math.sign(h1.timestamp - h2.timestamp));
|
2017-10-15 19:28:35 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
return { history };
|
2016-10-12 02:55:53 +02:00
|
|
|
}
|
|
|
|
|
2016-11-16 01:59:39 +01:00
|
|
|
async getDenoms(exchangeUrl: string): Promise<DenominationRecord[]> {
|
2019-06-26 15:30:32 +02:00
|
|
|
const denoms = await this.q()
|
|
|
|
.iterIndex(Stores.denominations.exchangeBaseUrlIndex, exchangeUrl)
|
|
|
|
.toArray();
|
2016-11-16 01:59:39 +01:00
|
|
|
return denoms;
|
|
|
|
}
|
2016-11-13 10:17:39 +01:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
async getProposal(
|
|
|
|
proposalId: number,
|
|
|
|
): Promise<ProposalDownloadRecord | undefined> {
|
2017-05-31 16:04:14 +02:00
|
|
|
const proposal = await this.q().get(Stores.proposals, proposalId);
|
|
|
|
return proposal;
|
2016-11-13 10:17:39 +01:00
|
|
|
}
|
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
async getExchanges(): Promise<ExchangeRecord[]> {
|
2016-10-13 02:23:24 +02:00
|
|
|
return this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter<ExchangeRecord>(Stores.exchanges)
|
|
|
|
.toArray();
|
2016-01-24 02:29:13 +01:00
|
|
|
}
|
2016-02-23 14:07:53 +01:00
|
|
|
|
2017-03-24 17:54:22 +01:00
|
|
|
async getCurrencies(): Promise<CurrencyRecord[]> {
|
|
|
|
return this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter<CurrencyRecord>(Stores.currencies)
|
|
|
|
.toArray();
|
2017-03-24 17:54:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
async updateCurrency(currencyRecord: CurrencyRecord): Promise<void> {
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("updating currency to", currencyRecord);
|
2017-03-24 17:54:22 +01:00
|
|
|
await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.put(Stores.currencies, currencyRecord)
|
|
|
|
.finish();
|
2017-03-24 17:54:22 +01:00
|
|
|
this.notifier.notify();
|
|
|
|
}
|
|
|
|
|
2016-10-13 02:23:24 +02:00
|
|
|
async getReserves(exchangeBaseUrl: string): Promise<ReserveRecord[]> {
|
|
|
|
return this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter<ReserveRecord>(Stores.reserves)
|
|
|
|
.filter((r: ReserveRecord) => r.exchange_base_url === exchangeBaseUrl)
|
|
|
|
.toArray();
|
2016-10-12 02:55:53 +02:00
|
|
|
}
|
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
async getCoins(exchangeBaseUrl: string): Promise<CoinRecord[]> {
|
2016-10-13 02:23:24 +02:00
|
|
|
return this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter<CoinRecord>(Stores.coins)
|
|
|
|
.filter((c: CoinRecord) => c.exchangeBaseUrl === exchangeBaseUrl)
|
|
|
|
.toArray();
|
2016-10-12 02:55:53 +02:00
|
|
|
}
|
|
|
|
|
2016-11-15 15:07:17 +01:00
|
|
|
async getPreCoins(exchangeBaseUrl: string): Promise<PreCoinRecord[]> {
|
2016-10-13 02:23:24 +02:00
|
|
|
return this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.iter<PreCoinRecord>(Stores.precoins)
|
|
|
|
.filter((c: PreCoinRecord) => c.exchangeBaseUrl === exchangeBaseUrl)
|
|
|
|
.toArray();
|
2016-10-12 02:55:53 +02:00
|
|
|
}
|
|
|
|
|
2017-06-01 18:46:07 +02:00
|
|
|
async hashContract(contract: ContractTerms): Promise<string> {
|
2016-09-28 23:41:34 +02:00
|
|
|
return this.cryptoApi.hashString(canonicalJson(contract));
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
async getCurrencyRecord(
|
|
|
|
currency: string,
|
|
|
|
): Promise<CurrencyRecord | undefined> {
|
2017-04-28 23:28:27 +02:00
|
|
|
return this.q().get(Stores.currencies, currency);
|
|
|
|
}
|
|
|
|
|
2017-05-01 04:05:16 +02:00
|
|
|
async payback(coinPub: string): Promise<void> {
|
|
|
|
let coin = await this.q().get(Stores.coins, coinPub);
|
|
|
|
if (!coin) {
|
|
|
|
throw Error(`Coin ${coinPub} not found, can't request payback`);
|
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
const reservePub = coin.reservePub;
|
2017-05-01 04:33:47 +02:00
|
|
|
if (!reservePub) {
|
|
|
|
throw Error(`Can't request payback for a refreshed coin`);
|
2017-05-01 04:05:16 +02:00
|
|
|
}
|
2017-05-28 01:10:54 +02:00
|
|
|
const reserve = await this.q().get(Stores.reserves, reservePub);
|
2017-05-01 04:05:16 +02:00
|
|
|
if (!reserve) {
|
|
|
|
throw Error(`Reserve of coin ${coinPub} not found`);
|
|
|
|
}
|
|
|
|
switch (coin.status) {
|
|
|
|
case CoinStatus.Refreshed:
|
2019-06-26 15:30:32 +02:00
|
|
|
throw Error(
|
|
|
|
`Can't do payback for coin ${coinPub} since it's refreshed`,
|
|
|
|
);
|
2017-05-01 04:05:16 +02:00
|
|
|
case CoinStatus.PaybackDone:
|
|
|
|
console.log(`Coin ${coinPub} already payed back`);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
coin.status = CoinStatus.PaybackPending;
|
|
|
|
// 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;
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.put(Stores.coins, coin)
|
|
|
|
.put(Stores.reserves, reserve);
|
2017-08-30 17:08:54 +02:00
|
|
|
this.notifier.notify();
|
2017-05-01 04:05:16 +02:00
|
|
|
|
2017-05-28 01:10:54 +02:00
|
|
|
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) {
|
2017-05-01 04:05:16 +02:00
|
|
|
throw Error();
|
|
|
|
}
|
2019-07-31 01:33:56 +02:00
|
|
|
const paybackConfirmation = PaybackConfirmation.checked(resp.responseJson);
|
2017-05-28 01:10:54 +02:00
|
|
|
if (paybackConfirmation.reserve_pub !== coin.reservePub) {
|
2017-05-01 04:05:16 +02:00
|
|
|
throw Error(`Coin's reserve doesn't match reserve on payback`);
|
|
|
|
}
|
|
|
|
coin = await this.q().get(Stores.coins, coinPub);
|
|
|
|
if (!coin) {
|
|
|
|
throw Error(`Coin ${coinPub} not found, can't confirm payback`);
|
|
|
|
}
|
|
|
|
coin.status = CoinStatus.PaybackDone;
|
|
|
|
await this.q().put(Stores.coins, coin);
|
2017-08-30 17:08:54 +02:00
|
|
|
this.notifier.notify();
|
2017-05-01 04:33:47 +02:00
|
|
|
await this.updateReserve(reservePub!);
|
2017-05-01 04:05:16 +02:00
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
async denominationRecordFromKeys(
|
|
|
|
exchangeBaseUrl: string,
|
|
|
|
denomIn: Denomination,
|
|
|
|
): Promise<DenominationRecord> {
|
2017-05-28 01:10:54 +02:00
|
|
|
const denomPubHash = await this.cryptoApi.hashDenomPub(denomIn.denom_pub);
|
|
|
|
const d: DenominationRecord = {
|
2017-05-01 04:05:16 +02:00
|
|
|
denomPub: denomIn.denom_pub,
|
2017-05-28 01:10:54 +02:00
|
|
|
denomPubHash,
|
|
|
|
exchangeBaseUrl,
|
2018-01-29 22:58:47 +01:00
|
|
|
feeDeposit: Amounts.parseOrThrow(denomIn.fee_deposit),
|
|
|
|
feeRefresh: Amounts.parseOrThrow(denomIn.fee_refresh),
|
|
|
|
feeRefund: Amounts.parseOrThrow(denomIn.fee_refund),
|
|
|
|
feeWithdraw: Amounts.parseOrThrow(denomIn.fee_withdraw),
|
2017-05-28 01:10:54 +02:00
|
|
|
isOffered: true,
|
|
|
|
masterSig: denomIn.master_sig,
|
2017-05-01 04:05:16 +02:00
|
|
|
stampExpireDeposit: denomIn.stamp_expire_deposit,
|
|
|
|
stampExpireLegal: denomIn.stamp_expire_legal,
|
|
|
|
stampExpireWithdraw: denomIn.stamp_expire_withdraw,
|
|
|
|
stampStart: denomIn.stamp_start,
|
|
|
|
status: DenominationStatus.Unverified,
|
2018-01-29 22:58:47 +01:00
|
|
|
value: Amounts.parseOrThrow(denomIn.value),
|
2017-05-01 04:05:16 +02:00
|
|
|
};
|
|
|
|
return d;
|
|
|
|
}
|
|
|
|
|
|
|
|
async withdrawPaybackReserve(reservePub: string): Promise<void> {
|
2017-05-28 01:10:54 +02:00
|
|
|
const reserve = await this.q().get(Stores.reserves, reservePub);
|
2017-05-01 04:05:16 +02:00
|
|
|
if (!reserve) {
|
|
|
|
throw Error(`Reserve ${reservePub} does not exist`);
|
|
|
|
}
|
|
|
|
reserve.hasPayback = false;
|
|
|
|
await this.q().put(Stores.reserves, reserve);
|
|
|
|
this.depleteReserve(reserve);
|
|
|
|
}
|
|
|
|
|
|
|
|
async getPaybackReserves(): Promise<ReserveRecord[]> {
|
2019-06-26 15:30:32 +02:00
|
|
|
return await this.q()
|
|
|
|
.iter(Stores.reserves)
|
|
|
|
.filter(r => r.hasPayback)
|
|
|
|
.toArray();
|
2017-05-01 04:05:16 +02:00
|
|
|
}
|
|
|
|
|
2017-06-05 02:00:03 +02:00
|
|
|
/**
|
|
|
|
* Stop ongoing processing.
|
|
|
|
*/
|
|
|
|
stop() {
|
|
|
|
this.timerGroup.stopCurrentAndFutureTimers();
|
2019-08-01 23:21:15 +02:00
|
|
|
this.cryptoApi.stop();
|
2017-06-05 02:00:03 +02:00
|
|
|
}
|
2017-08-14 04:16:12 +02:00
|
|
|
|
|
|
|
async getSenderWireInfos(): Promise<SenderWireInfos> {
|
|
|
|
const m: { [url: string]: Set<string> } = {};
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.iter(Stores.exchangeWireFees)
|
|
|
|
.map(x => {
|
|
|
|
const s = (m[x.exchangeBaseUrl] = m[x.exchangeBaseUrl] || new Set());
|
|
|
|
Object.keys(x.feesForType).map(k => s.add(k));
|
|
|
|
})
|
|
|
|
.run();
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log(m);
|
2017-08-14 04:16:12 +02:00
|
|
|
const exchangeWireTypes: { [url: string]: string[] } = {};
|
2019-06-26 15:30:32 +02:00
|
|
|
Object.keys(m).map(e => {
|
|
|
|
exchangeWireTypes[e] = Array.from(m[e]);
|
|
|
|
});
|
2017-08-14 04:16:12 +02:00
|
|
|
|
2019-07-21 23:50:10 +02:00
|
|
|
const senderWiresSet: Set<string> = new Set();
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.iter(Stores.senderWires)
|
|
|
|
.map(x => {
|
2019-05-08 04:53:26 +02:00
|
|
|
senderWiresSet.add(x.paytoUri);
|
2019-06-26 15:30:32 +02:00
|
|
|
})
|
|
|
|
.run();
|
2019-07-21 23:50:10 +02:00
|
|
|
const senderWires: string[] = Array.from(senderWiresSet);
|
2017-08-14 04:16:12 +02:00
|
|
|
|
|
|
|
return {
|
|
|
|
exchangeWireTypes,
|
|
|
|
senderWires,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Trigger paying coins back into the user's account.
|
|
|
|
*/
|
|
|
|
async returnCoins(req: ReturnCoinsRequest): Promise<void> {
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("got returnCoins request", req);
|
2017-08-14 04:16:12 +02:00
|
|
|
const wireType = (req.senderWire as any).type;
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("wireType", wireType);
|
2017-08-14 04:16:12 +02:00
|
|
|
if (!wireType || typeof wireType !== "string") {
|
|
|
|
console.error(`wire type must be a non-empty string, not ${wireType}`);
|
|
|
|
return;
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
const stampSecNow = Math.floor(new Date().getTime() / 1000);
|
2017-08-14 04:16:12 +02:00
|
|
|
const exchange = await this.q().get(Stores.exchanges, req.exchange);
|
|
|
|
if (!exchange) {
|
|
|
|
console.error(`Exchange ${req.exchange} not known to the wallet`);
|
|
|
|
return;
|
|
|
|
}
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("selecting coins for return:", req);
|
2017-08-14 04:16:12 +02:00
|
|
|
const cds = await this.getCoinsForReturn(req.exchange, req.amount);
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log(cds);
|
2017-08-14 04:16:12 +02:00
|
|
|
|
|
|
|
if (!cds) {
|
|
|
|
throw Error("coin return impossible, can't select coins");
|
|
|
|
}
|
|
|
|
|
|
|
|
const { priv, pub } = await this.cryptoApi.createEddsaKeypair();
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const wireHash = await this.cryptoApi.hashString(
|
|
|
|
canonicalJson(req.senderWire),
|
|
|
|
);
|
2017-08-14 04:16:12 +02:00
|
|
|
|
|
|
|
const contractTerms: ContractTerms = {
|
|
|
|
H_wire: wireHash,
|
2018-01-29 22:58:47 +01:00
|
|
|
amount: Amounts.toString(req.amount),
|
2017-08-14 04:16:12 +02:00
|
|
|
auditors: [],
|
2019-06-26 15:30:32 +02:00
|
|
|
exchanges: [
|
|
|
|
{ master_pub: exchange.masterPublicKey, url: exchange.baseUrl },
|
|
|
|
],
|
2017-10-15 19:28:35 +02:00
|
|
|
extra: {},
|
|
|
|
fulfillment_url: "",
|
2017-08-14 04:16:12 +02:00
|
|
|
locations: [],
|
2018-01-29 22:58:47 +01:00
|
|
|
max_fee: Amounts.toString(req.amount),
|
2017-08-14 04:16:12 +02:00
|
|
|
merchant: {},
|
|
|
|
merchant_pub: pub,
|
2017-10-15 19:28:35 +02:00
|
|
|
order_id: "none",
|
|
|
|
pay_deadline: `/Date(${stampSecNow + 60 * 5})/`,
|
|
|
|
pay_url: "",
|
2017-08-14 04:16:12 +02:00
|
|
|
products: [],
|
|
|
|
refund_deadline: `/Date(${stampSecNow + 60 * 5})/`,
|
|
|
|
timestamp: `/Date(${stampSecNow})/`,
|
2017-10-15 19:28:35 +02:00
|
|
|
wire_method: wireType,
|
2017-08-14 04:16:12 +02:00
|
|
|
};
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const contractTermsHash = await this.cryptoApi.hashString(
|
|
|
|
canonicalJson(contractTerms),
|
|
|
|
);
|
2017-08-14 04:16:12 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const payCoinInfo = await this.cryptoApi.signDeposit(
|
|
|
|
contractTerms,
|
|
|
|
cds,
|
|
|
|
Amounts.parseOrThrow(contractTerms.amount),
|
2018-01-29 22:58:47 +01:00
|
|
|
);
|
2017-08-14 04:16:12 +02:00
|
|
|
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("pci", payCoinInfo);
|
2017-08-14 04:16:12 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const coins = payCoinInfo.sigs.map(s => ({ coinPaySig: s }));
|
2017-08-14 04:16:12 +02:00
|
|
|
|
|
|
|
const coinsReturnRecord: CoinsReturnRecord = {
|
|
|
|
coins,
|
|
|
|
contractTerms,
|
|
|
|
contractTermsHash,
|
2017-10-15 19:28:35 +02:00
|
|
|
exchange: exchange.baseUrl,
|
2017-08-14 04:16:12 +02:00
|
|
|
merchantPriv: priv,
|
|
|
|
wire: req.senderWire,
|
2017-10-15 19:28:35 +02:00
|
|
|
};
|
2017-08-14 04:16:12 +02:00
|
|
|
|
|
|
|
await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.put(Stores.coinsReturns, coinsReturnRecord)
|
|
|
|
.putAll(Stores.coins, payCoinInfo.updatedCoins)
|
|
|
|
.finish();
|
2017-12-12 16:39:55 +01:00
|
|
|
this.badge.showNotification();
|
2017-08-30 17:08:54 +02:00
|
|
|
this.notifier.notify();
|
2017-08-14 04:16:12 +02:00
|
|
|
|
|
|
|
this.depositReturnedCoins(coinsReturnRecord);
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
async depositReturnedCoins(
|
|
|
|
coinsReturnRecord: CoinsReturnRecord,
|
|
|
|
): Promise<void> {
|
2017-08-14 04:16:12 +02:00
|
|
|
for (const c of coinsReturnRecord.coins) {
|
|
|
|
if (c.depositedSig) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
const req = {
|
|
|
|
H_wire: coinsReturnRecord.contractTerms.H_wire,
|
|
|
|
coin_pub: c.coinPaySig.coin_pub,
|
2017-10-15 19:28:35 +02:00
|
|
|
coin_sig: c.coinPaySig.coin_sig,
|
2018-01-01 18:56:22 +01:00
|
|
|
contribution: c.coinPaySig.contribution,
|
2018-01-03 14:42:06 +01:00
|
|
|
denom_pub: c.coinPaySig.denom_pub,
|
2017-10-15 19:28:35 +02:00
|
|
|
h_contract_terms: coinsReturnRecord.contractTermsHash,
|
|
|
|
merchant_pub: coinsReturnRecord.contractTerms.merchant_pub,
|
2017-08-14 04:16:12 +02:00
|
|
|
pay_deadline: coinsReturnRecord.contractTerms.pay_deadline,
|
|
|
|
refund_deadline: coinsReturnRecord.contractTerms.refund_deadline,
|
2017-10-15 19:28:35 +02:00
|
|
|
timestamp: coinsReturnRecord.contractTerms.timestamp,
|
|
|
|
ub_sig: c.coinPaySig.ub_sig,
|
|
|
|
wire: coinsReturnRecord.wire,
|
|
|
|
wire_transfer_deadline: coinsReturnRecord.contractTerms.pay_deadline,
|
2017-08-14 04:16:12 +02:00
|
|
|
};
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("req", req);
|
2019-06-26 15:30:32 +02:00
|
|
|
const reqUrl = new URI("deposit").absoluteTo(coinsReturnRecord.exchange);
|
2017-08-14 04:16:12 +02:00
|
|
|
const resp = await this.http.postJson(reqUrl.href(), req);
|
|
|
|
if (resp.status !== 200) {
|
|
|
|
console.error("deposit failed due to status code", resp);
|
|
|
|
continue;
|
|
|
|
}
|
2019-07-31 01:33:56 +02:00
|
|
|
const respJson = resp.responseJson;
|
2017-08-14 04:16:12 +02:00
|
|
|
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
|
2019-06-26 15:30:32 +02:00
|
|
|
const currentCrr = await this.q().get(
|
|
|
|
Stores.coinsReturns,
|
|
|
|
coinsReturnRecord.contractTermsHash,
|
|
|
|
);
|
2017-08-14 04:16:12 +02:00
|
|
|
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 this.q().put(Stores.coinsReturns, currentCrr);
|
2017-08-30 17:08:54 +02:00
|
|
|
this.notifier.notify();
|
2017-08-14 04:16:12 +02:00
|
|
|
}
|
|
|
|
}
|
2017-08-27 03:56:19 +02:00
|
|
|
|
2019-08-31 11:49:36 +02:00
|
|
|
private async acceptRefundResponse(
|
2019-06-26 15:30:32 +02:00
|
|
|
refundResponse: MerchantRefundResponse,
|
|
|
|
): Promise<string> {
|
2018-01-29 16:41:17 +01:00
|
|
|
const refundPermissions = refundResponse.refund_permissions;
|
2018-01-17 03:49:54 +01:00
|
|
|
|
2017-08-27 03:56:19 +02:00
|
|
|
if (!refundPermissions.length) {
|
|
|
|
console.warn("got empty refund list");
|
2018-01-17 03:49:54 +01:00
|
|
|
throw Error("empty refund");
|
2017-08-27 03:56:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add refund to purchase if not already added.
|
|
|
|
*/
|
2019-06-26 15:30:32 +02:00
|
|
|
function f(t: PurchaseRecord | undefined): PurchaseRecord | undefined {
|
2017-08-27 03:56:19 +02:00
|
|
|
if (!t) {
|
|
|
|
console.error("purchase not found, not adding refunds");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
t.timestamp_refund = new Date().getTime();
|
2017-10-15 18:30:02 +02:00
|
|
|
|
2017-08-27 03:56:19 +02:00
|
|
|
for (const perm of refundPermissions) {
|
2019-06-26 15:30:32 +02:00
|
|
|
if (
|
|
|
|
!t.refundsPending[perm.merchant_sig] &&
|
|
|
|
!t.refundsDone[perm.merchant_sig]
|
|
|
|
) {
|
2017-08-27 03:56:19 +02:00
|
|
|
t.refundsPending[perm.merchant_sig] = perm;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
2018-01-29 16:41:17 +01:00
|
|
|
const hc = refundResponse.h_contract_terms;
|
|
|
|
|
2017-08-27 03:56:19 +02:00
|
|
|
// Add the refund permissions to the purchase within a DB transaction
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.mutate(Stores.purchases, hc, f)
|
|
|
|
.finish();
|
2017-08-27 03:56:19 +02:00
|
|
|
this.notifier.notify();
|
|
|
|
|
2019-08-31 11:49:36 +02:00
|
|
|
await this.submitRefunds(hc);
|
2018-01-17 03:49:54 +01:00
|
|
|
|
2018-01-29 16:41:17 +01:00
|
|
|
return hc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Accept a refund, return the contract hash for the contract
|
|
|
|
* that was involved in the refund.
|
|
|
|
*/
|
2019-08-31 11:49:36 +02:00
|
|
|
async applyRefund(talerRefundUri: string): Promise<string> {
|
|
|
|
const parseResult = parseRefundUri(talerRefundUri);
|
|
|
|
|
|
|
|
if (!parseResult) {
|
|
|
|
throw Error("invalid refund URI");
|
|
|
|
}
|
|
|
|
|
|
|
|
const refundUrl = parseResult.refundUrl;
|
|
|
|
|
2019-08-26 01:39:13 +02:00
|
|
|
Wallet.enableTracing && console.log("processing refund");
|
2018-01-29 16:41:17 +01:00
|
|
|
let resp;
|
|
|
|
try {
|
2019-08-22 23:36:36 +02:00
|
|
|
resp = await this.http.get(refundUrl);
|
2018-01-29 16:41:17 +01:00
|
|
|
} catch (e) {
|
2019-08-26 01:39:13 +02:00
|
|
|
console.error("error downloading refund permission", e);
|
2018-01-29 16:41:17 +01:00
|
|
|
throw e;
|
|
|
|
}
|
|
|
|
|
2019-08-22 23:36:36 +02:00
|
|
|
const refundResponse = MerchantRefundResponse.checked(resp.responseJson);
|
2018-01-29 16:41:17 +01:00
|
|
|
return this.acceptRefundResponse(refundResponse);
|
2017-08-27 03:56:19 +02:00
|
|
|
}
|
|
|
|
|
2018-01-22 01:12:08 +01:00
|
|
|
private async submitRefunds(contractTermsHash: string): Promise<void> {
|
2017-08-27 03:56:19 +02:00
|
|
|
const purchase = await this.q().get(Stores.purchases, contractTermsHash);
|
|
|
|
if (!purchase) {
|
2019-06-26 15:30:32 +02:00
|
|
|
console.error(
|
|
|
|
"not submitting refunds, contract terms not found:",
|
|
|
|
contractTermsHash,
|
|
|
|
);
|
2017-08-27 03:56:19 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
const pendingKeys = Object.keys(purchase.refundsPending);
|
|
|
|
if (pendingKeys.length === 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (const pk of pendingKeys) {
|
|
|
|
const perm = purchase.refundsPending[pk];
|
2018-01-29 16:41:17 +01:00
|
|
|
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,
|
|
|
|
};
|
2017-08-27 03:56:19 +02:00
|
|
|
console.log("sending refund permission", perm);
|
2018-01-04 13:22:23 +01:00
|
|
|
// FIXME: not correct once we support multiple exchanges per payment
|
|
|
|
const exchangeUrl = purchase.payReq.coins[0].exchange_url;
|
2019-06-26 15:30:32 +02:00
|
|
|
const reqUrl = new URI("refund").absoluteTo(exchangeUrl);
|
2018-01-29 16:41:17 +01:00
|
|
|
const resp = await this.http.postJson(reqUrl.href(), req);
|
2017-08-27 03:56:19 +02:00
|
|
|
if (resp.status !== 200) {
|
|
|
|
console.error("refund failed", resp);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Transactionally mark successful refunds as done
|
2019-06-26 15:30:32 +02:00
|
|
|
const transformPurchase = (
|
|
|
|
t: PurchaseRecord | undefined,
|
|
|
|
): PurchaseRecord | undefined => {
|
2017-08-27 03:56:19 +02:00
|
|
|
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;
|
|
|
|
};
|
2019-06-26 15:30:32 +02:00
|
|
|
const transformCoin = (
|
|
|
|
c: CoinRecord | undefined,
|
|
|
|
): CoinRecord | undefined => {
|
2017-08-27 03:56:19 +02:00
|
|
|
if (!c) {
|
|
|
|
console.warn("coin not found, can't apply refund");
|
|
|
|
return;
|
|
|
|
}
|
2018-01-29 22:58:47 +01:00
|
|
|
const refundAmount = Amounts.parseOrThrow(perm.refund_amount);
|
|
|
|
const refundFee = Amounts.parseOrThrow(perm.refund_fee);
|
2017-08-27 03:56:19 +02:00
|
|
|
c.status = CoinStatus.Dirty;
|
2018-01-29 22:58:47 +01:00
|
|
|
c.currentAmount = Amounts.add(c.currentAmount, refundAmount).amount;
|
|
|
|
c.currentAmount = Amounts.sub(c.currentAmount, refundFee).amount;
|
2017-08-27 03:56:19 +02:00
|
|
|
|
|
|
|
return c;
|
|
|
|
};
|
|
|
|
|
|
|
|
await this.q()
|
2019-06-26 15:30:32 +02:00
|
|
|
.mutate(Stores.purchases, contractTermsHash, transformPurchase)
|
|
|
|
.mutate(Stores.coins, perm.coin_pub, transformCoin)
|
|
|
|
.finish();
|
2017-08-27 03:56:19 +02:00
|
|
|
this.refresh(perm.coin_pub);
|
|
|
|
}
|
|
|
|
|
2017-12-12 16:39:55 +01:00
|
|
|
this.badge.showNotification();
|
2017-08-27 03:56:19 +02:00
|
|
|
this.notifier.notify();
|
|
|
|
}
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
async getPurchase(
|
|
|
|
contractTermsHash: string,
|
|
|
|
): Promise<PurchaseRecord | undefined> {
|
2017-08-27 03:56:19 +02:00
|
|
|
return this.q().get(Stores.purchases, contractTermsHash);
|
|
|
|
}
|
2017-08-30 17:08:54 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
async getFullRefundFees(
|
|
|
|
refundPermissions: MerchantRefundPermission[],
|
|
|
|
): Promise<AmountJson> {
|
2017-08-30 17:08:54 +02:00
|
|
|
if (refundPermissions.length === 0) {
|
|
|
|
throw Error("no refunds given");
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
const coin0 = await this.q().get(
|
|
|
|
Stores.coins,
|
|
|
|
refundPermissions[0].coin_pub,
|
|
|
|
);
|
2017-08-30 17:08:54 +02:00
|
|
|
if (!coin0) {
|
|
|
|
throw Error("coin not found");
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
let feeAcc = Amounts.getZero(
|
|
|
|
Amounts.parseOrThrow(refundPermissions[0].refund_amount).currency,
|
|
|
|
);
|
2017-08-30 17:08:54 +02:00
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
const denoms = await this.q()
|
|
|
|
.iterIndex(
|
|
|
|
Stores.denominations.exchangeBaseUrlIndex,
|
|
|
|
coin0.exchangeBaseUrl,
|
|
|
|
)
|
|
|
|
.toArray();
|
2017-08-30 17:08:54 +02:00
|
|
|
for (const rp of refundPermissions) {
|
|
|
|
const coin = await this.q().get(Stores.coins, rp.coin_pub);
|
|
|
|
if (!coin) {
|
|
|
|
throw Error("coin not found");
|
|
|
|
}
|
2019-06-26 15:30:32 +02:00
|
|
|
const denom = await this.q().get(Stores.denominations, [
|
|
|
|
coin0.exchangeBaseUrl,
|
|
|
|
coin.denomPub,
|
|
|
|
]);
|
2017-08-30 17:08:54 +02:00
|
|
|
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?)
|
2018-01-29 22:58:47 +01:00
|
|
|
const refundAmount = Amounts.parseOrThrow(rp.refund_amount);
|
|
|
|
const refundFee = Amounts.parseOrThrow(rp.refund_fee);
|
2019-06-26 15:30:32 +02:00
|
|
|
const refreshCost = getTotalRefreshCost(
|
|
|
|
denoms,
|
|
|
|
denom,
|
|
|
|
Amounts.sub(refundAmount, refundFee).amount,
|
|
|
|
);
|
2018-01-29 22:58:47 +01:00
|
|
|
feeAcc = Amounts.add(feeAcc, refreshCost, refundFee).amount;
|
2017-08-30 17:08:54 +02:00
|
|
|
}
|
|
|
|
return feeAcc;
|
|
|
|
}
|
2017-11-30 04:07:36 +01:00
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
async acceptTip(talerTipUri: string): Promise<void> {
|
|
|
|
const { tipId, merchantOrigin } = await this.getTipStatus(talerTipUri);
|
|
|
|
const key = `${tipId}${merchantOrigin}`;
|
2018-02-01 07:19:03 +01:00
|
|
|
if (this.activeTipOperations[key]) {
|
|
|
|
return this.activeTipOperations[key];
|
|
|
|
}
|
2019-08-30 17:27:59 +02:00
|
|
|
const p = this.acceptTipImpl(tipId, merchantOrigin);
|
2018-04-09 00:41:14 +02:00
|
|
|
this.activeTipOperations[key] = p;
|
2018-02-01 07:19:03 +01:00
|
|
|
try {
|
|
|
|
return await p;
|
|
|
|
} finally {
|
|
|
|
delete this.activeTipOperations[key];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
private async acceptTipImpl(
|
|
|
|
tipId: string,
|
|
|
|
merchantOrigin: string,
|
|
|
|
): Promise<void> {
|
|
|
|
let tipRecord = await this.q().get(Stores.tips, [tipId, merchantOrigin]);
|
|
|
|
if (!tipRecord) {
|
|
|
|
throw Error("tip not in database");
|
2018-01-17 03:49:54 +01:00
|
|
|
}
|
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
tipRecord.accepted = true;
|
2018-01-17 03:49:54 +01:00
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
// Create one transactional query, within this transaction
|
|
|
|
// both the tip will be marked as accepted and coins
|
|
|
|
// already withdrawn will be untainted.
|
|
|
|
await this.q()
|
|
|
|
.put(Stores.tips, tipRecord)
|
|
|
|
.finish();
|
|
|
|
|
|
|
|
if (tipRecord.pickedUp) {
|
|
|
|
console.log("tip already picked up");
|
|
|
|
return;
|
2018-01-17 03:49:54 +01:00
|
|
|
}
|
2019-08-30 17:27:59 +02:00
|
|
|
await this.updateExchangeFromUrl(tipRecord.exchangeUrl);
|
2019-06-26 15:30:32 +02:00
|
|
|
const denomsForWithdraw = await this.getVerifiedWithdrawDenomList(
|
2019-08-30 17:27:59 +02:00
|
|
|
tipRecord.exchangeUrl,
|
|
|
|
tipRecord.amount,
|
2019-06-26 15:30:32 +02:00
|
|
|
);
|
2018-01-19 01:27:27 +01:00
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
if (!tipRecord.planchets) {
|
|
|
|
const planchets = await Promise.all(
|
|
|
|
denomsForWithdraw.map(d => this.cryptoApi.createTipPlanchet(d)),
|
|
|
|
);
|
|
|
|
const coinPubs: string[] = planchets.map(x => x.coinPub);
|
2018-02-01 07:19:03 +01:00
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
await this.q().mutate(Stores.tips, [tipId, merchantOrigin], r => {
|
|
|
|
if (!r.planchets) {
|
|
|
|
r.planchets = planchets;
|
|
|
|
r.coinPubs = coinPubs;
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
});
|
|
|
|
|
|
|
|
this.notifier.notify();
|
|
|
|
}
|
|
|
|
|
|
|
|
tipRecord = await this.q().get(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!");
|
2018-02-01 07:19:03 +01:00
|
|
|
|
2018-01-19 01:27:27 +01:00
|
|
|
// Planchets in the form that the merchant expects
|
2019-06-26 15:30:32 +02:00
|
|
|
const planchetsDetail: TipPlanchetDetail[] = tipRecord.planchets.map(p => ({
|
2018-01-19 01:27:27 +01:00
|
|
|
coin_ev: p.coinEv,
|
|
|
|
denom_pub_hash: p.denomPubHash,
|
|
|
|
}));
|
2018-01-17 03:49:54 +01:00
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
let merchantResp;
|
|
|
|
|
2018-01-17 03:49:54 +01:00
|
|
|
try {
|
2019-08-30 17:27:59 +02:00
|
|
|
const req = { planchets: planchetsDetail, tip_id: tipId };
|
|
|
|
merchantResp = await this.http.postJson(tipRecord.pickupUrl, req);
|
|
|
|
console.log("got merchant resp:", merchantResp);
|
2018-01-17 03:49:54 +01:00
|
|
|
} catch (e) {
|
|
|
|
console.log("tipping failed", e);
|
|
|
|
throw e;
|
|
|
|
}
|
|
|
|
|
2019-08-22 23:36:36 +02:00
|
|
|
const response = TipResponse.checked(merchantResp.responseJson);
|
2018-01-17 03:49:54 +01:00
|
|
|
|
2017-11-30 04:07:36 +01:00
|
|
|
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++) {
|
2018-01-03 14:42:06 +01:00
|
|
|
const planchet = tipRecord.planchets[i];
|
|
|
|
const preCoin = {
|
|
|
|
blindingKey: planchet.blindingKey,
|
2017-11-30 04:07:36 +01:00
|
|
|
coinEv: planchet.coinEv,
|
2018-01-03 14:42:06 +01:00
|
|
|
coinPriv: planchet.coinPriv,
|
|
|
|
coinPub: planchet.coinPub,
|
2017-11-30 04:07:36 +01:00
|
|
|
coinValue: planchet.coinValue,
|
|
|
|
denomPub: planchet.denomPub,
|
2019-05-08 07:01:17 +02:00
|
|
|
denomPubHash: planchet.denomPubHash,
|
2017-11-30 04:07:36 +01:00
|
|
|
exchangeBaseUrl: tipRecord.exchangeUrl,
|
|
|
|
isFromTip: true,
|
2018-01-03 14:42:06 +01:00
|
|
|
reservePub: response.reserve_pub,
|
|
|
|
withdrawSig: response.reserve_sigs[i].reserve_sig,
|
2017-11-30 04:07:36 +01:00
|
|
|
};
|
|
|
|
await this.q().put(Stores.precoins, preCoin);
|
2019-08-30 17:27:59 +02:00
|
|
|
await this.processPreCoin(preCoin.coinPub);
|
2017-11-30 04:07:36 +01:00
|
|
|
}
|
2018-01-19 01:27:27 +01:00
|
|
|
|
|
|
|
tipRecord.pickedUp = true;
|
|
|
|
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q()
|
|
|
|
.put(Stores.tips, tipRecord)
|
|
|
|
.finish();
|
2018-04-09 00:20:54 +02:00
|
|
|
this.notifier.notify();
|
2019-08-30 17:27:59 +02:00
|
|
|
this.badge.showNotification();
|
|
|
|
return;
|
2017-11-30 04:07:36 +01:00
|
|
|
}
|
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
async getTipStatus(talerTipUri: string): Promise<TipStatus> {
|
|
|
|
const res = parseTipUri(talerTipUri);
|
|
|
|
if (!res) {
|
|
|
|
throw Error("invalid taler://tip URI");
|
2017-11-30 04:07:36 +01:00
|
|
|
}
|
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
const tipStatusUrl = new URI(res.tipPickupUrl)
|
2019-10-01 20:45:36 +02:00
|
|
|
.addQuery({ tip_id: res.tipId })
|
2019-08-30 17:27:59 +02:00
|
|
|
.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,
|
|
|
|
);
|
2017-11-30 04:07:36 +01:00
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
console.log("status", tipPickupStatus);
|
2017-11-30 04:07:36 +01:00
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
let amount = Amounts.parseOrThrow(tipPickupStatus.amount);
|
2017-11-30 04:07:36 +01:00
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
let tipRecord = await this.q().get(Stores.tips, [
|
|
|
|
res.tipId,
|
|
|
|
res.merchantOrigin,
|
|
|
|
]);
|
|
|
|
if (!tipRecord) {
|
|
|
|
const withdrawDetails = await this.getWithdrawDetailsForAmount(
|
|
|
|
tipPickupStatus.exchange_url,
|
|
|
|
amount,
|
|
|
|
);
|
2017-11-30 04:07:36 +01:00
|
|
|
|
2019-08-30 17:27:59 +02:00
|
|
|
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: new Date().getTime(),
|
|
|
|
tipId: res.tipId,
|
|
|
|
pickupUrl: res.tipPickupUrl,
|
2019-08-31 13:27:12 +02:00
|
|
|
totalFees: Amounts.add(
|
|
|
|
withdrawDetails.overhead,
|
|
|
|
withdrawDetails.withdrawFee,
|
|
|
|
).amount,
|
2019-08-30 17:27:59 +02:00
|
|
|
};
|
|
|
|
await this.q().put(Stores.tips, tipRecord);
|
|
|
|
}
|
2017-11-30 04:07:36 +01:00
|
|
|
|
|
|
|
const tipStatus: TipStatus = {
|
2018-02-01 07:19:03 +01:00
|
|
|
accepted: !!tipRecord && tipRecord.accepted,
|
2019-08-30 17:27:59 +02:00
|
|
|
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,
|
2017-11-30 04:07:36 +01:00
|
|
|
};
|
2019-08-30 17:27:59 +02:00
|
|
|
|
2017-11-30 04:07:36 +01:00
|
|
|
return tipStatus;
|
|
|
|
}
|
2017-12-10 21:34:56 +01:00
|
|
|
|
2018-01-29 16:41:17 +01:00
|
|
|
async abortFailedPayment(contractTermsHash: string): Promise<void> {
|
|
|
|
const purchase = await this.q().get(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 this.q().put(Stores.purchases, purchase);
|
|
|
|
|
|
|
|
let resp;
|
|
|
|
|
|
|
|
const abortReq = { ...purchase.payReq, mode: "abort-refund" };
|
|
|
|
|
|
|
|
try {
|
2019-08-22 23:36:36 +02:00
|
|
|
resp = await this.http.postJson(purchase.contractTerms.pay_url, abortReq);
|
2018-01-29 16:41:17 +01:00
|
|
|
} catch (e) {
|
|
|
|
// Gives the user the option to retry / abort and refresh
|
|
|
|
console.log("aborting payment failed", e);
|
|
|
|
throw e;
|
|
|
|
}
|
|
|
|
|
2019-08-22 23:36:36 +02:00
|
|
|
const refundResponse = MerchantRefundResponse.checked(resp.responseJson);
|
2018-01-29 16:41:17 +01:00
|
|
|
await this.acceptRefundResponse(refundResponse);
|
|
|
|
|
|
|
|
const markAbortDone = (p: PurchaseRecord) => {
|
|
|
|
p.abortDone = true;
|
|
|
|
return p;
|
|
|
|
};
|
2019-06-26 15:30:32 +02:00
|
|
|
await this.q().mutate(
|
|
|
|
Stores.purchases,
|
|
|
|
purchase.contractTermsHash,
|
|
|
|
markAbortDone,
|
|
|
|
);
|
2018-01-29 16:41:17 +01:00
|
|
|
}
|
|
|
|
|
2017-12-10 21:34:56 +01:00
|
|
|
/**
|
|
|
|
* Remove unreferenced / expired data from the wallet's database
|
|
|
|
* based on the current system time.
|
|
|
|
*/
|
|
|
|
async collectGarbage() {
|
2019-08-20 17:58:01 +02:00
|
|
|
// 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.
|
2017-12-10 21:34:56 +01:00
|
|
|
}
|
2017-12-12 16:39:55 +01:00
|
|
|
|
2019-09-01 01:05:38 +02:00
|
|
|
async getWithdrawalInfo(
|
2019-08-28 02:49:27 +02:00
|
|
|
talerWithdrawUri: string,
|
|
|
|
): Promise<DownloadedWithdrawInfo> {
|
|
|
|
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,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-08-29 23:12:55 +02:00
|
|
|
async acceptWithdrawal(
|
2019-08-28 02:49:27 +02:00
|
|
|
talerWithdrawUri: string,
|
|
|
|
selectedExchange: string,
|
2019-08-29 23:12:55 +02:00
|
|
|
): Promise<AcceptWithdrawalResponse> {
|
2019-09-01 01:05:38 +02:00
|
|
|
const withdrawInfo = await this.getWithdrawalInfo(talerWithdrawUri);
|
2019-08-28 02:49:27 +02:00
|
|
|
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,
|
|
|
|
});
|
2019-08-29 23:12:55 +02:00
|
|
|
await this.sendReserveInfoToBank(reserve.reservePub);
|
2019-08-28 02:49:27 +02:00
|
|
|
return {
|
|
|
|
reservePub: reserve.reservePub,
|
|
|
|
confirmTransferUrl: withdrawInfo.confirmTransferUrl,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-08-31 13:27:12 +02:00
|
|
|
async getPurchaseDetails(hc: string): Promise<PurchaseDetails> {
|
|
|
|
const purchase = await this.q().get(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),
|
|
|
|
);
|
2019-09-04 15:28:19 +02:00
|
|
|
const refundsPendingFees = Object.values(purchase.refundsPending).map(x =>
|
|
|
|
Amounts.parseOrThrow(x.refund_amount),
|
2019-08-31 13:27:12 +02:00
|
|
|
);
|
|
|
|
const totalRefundFees = Amounts.sum([
|
|
|
|
...refundsDoneFees,
|
|
|
|
...refundsPendingFees,
|
|
|
|
]).amount;
|
|
|
|
const totalFees = totalRefundFees;
|
|
|
|
return {
|
|
|
|
contractTerms: purchase.contractTerms,
|
|
|
|
hasRefund: purchase.timestamp_refund !== 0,
|
|
|
|
totalRefundAmount: totalRefundAmount,
|
|
|
|
totalRefundAndRefreshFees: totalFees,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-08-28 02:49:27 +02:00
|
|
|
/**
|
|
|
|
* Reset the retry timeouts for ongoing operations.
|
|
|
|
*/
|
|
|
|
resetRetryTimeouts(): void {
|
|
|
|
// FIXME: implement
|
|
|
|
}
|
|
|
|
|
2017-12-12 16:39:55 +01:00
|
|
|
clearNotification(): void {
|
|
|
|
this.badge.clearNotification();
|
|
|
|
}
|
2018-09-20 02:56:13 +02:00
|
|
|
|
|
|
|
benchmarkCrypto(repetitions: number): Promise<BenchmarkResult> {
|
|
|
|
return this.cryptoApi.benchmark(repetitions);
|
|
|
|
}
|
2016-10-18 01:16:31 +02:00
|
|
|
}
|