2019-12-02 00:42:40 +01:00
|
|
|
/*
|
|
|
|
This file is part of GNU Taler
|
|
|
|
(C) 2019 GNUnet e.V.
|
|
|
|
|
|
|
|
GNU Taler is free software; you can redistribute it and/or modify it under the
|
|
|
|
terms of the GNU General Public License as published by the Free Software
|
|
|
|
Foundation; either version 3, or (at your option) any later version.
|
|
|
|
|
|
|
|
GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
|
|
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
|
|
GNU Taler; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
|
|
|
|
*/
|
|
|
|
|
2021-02-08 15:38:34 +01:00
|
|
|
import { encodeCrock, getRandomBytes } from "../crypto/talerCrypto";
|
2019-12-02 00:42:40 +01:00
|
|
|
import {
|
|
|
|
CoinRecord,
|
2020-03-11 20:14:28 +01:00
|
|
|
CoinSourceType,
|
2021-02-08 15:38:34 +01:00
|
|
|
CoinStatus,
|
|
|
|
DenominationRecord,
|
|
|
|
RefreshGroupRecord,
|
|
|
|
RefreshPlanchet,
|
|
|
|
Stores,
|
2021-03-17 17:56:37 +01:00
|
|
|
} from "../db.js";
|
2021-02-08 15:38:34 +01:00
|
|
|
import {
|
|
|
|
codecForExchangeMeltResponse,
|
|
|
|
codecForExchangeRevealResponse,
|
2019-12-15 16:59:00 +01:00
|
|
|
CoinPublicKey,
|
2021-03-17 17:56:37 +01:00
|
|
|
NotificationType,
|
2019-12-15 16:59:00 +01:00
|
|
|
RefreshGroupId,
|
2021-02-08 15:38:34 +01:00
|
|
|
RefreshReason,
|
|
|
|
TalerErrorDetails,
|
2021-03-17 17:56:37 +01:00
|
|
|
} from "@gnu-taler/taler-util";
|
|
|
|
import { AmountJson, Amounts } from "@gnu-taler/taler-util";
|
2021-02-08 15:38:34 +01:00
|
|
|
import { amountToPretty } from "../util/helpers";
|
|
|
|
import { readSuccessResponseJsonOrThrow } from "../util/http";
|
|
|
|
import { checkDbInvariant } from "../util/invariants";
|
|
|
|
import { Logger } from "../util/logging";
|
|
|
|
import { TransactionHandle } from "../util/query";
|
|
|
|
import { initRetryInfo, updateRetryInfoTimeout } from "../util/retries";
|
2020-09-03 17:08:26 +02:00
|
|
|
import {
|
|
|
|
Duration,
|
|
|
|
durationFromSpec,
|
2021-02-08 15:38:34 +01:00
|
|
|
durationMul,
|
|
|
|
getTimestampNow,
|
|
|
|
isTimestampExpired,
|
|
|
|
Timestamp,
|
2020-09-03 17:08:26 +02:00
|
|
|
timestampAddDuration,
|
|
|
|
timestampDifference,
|
2021-02-08 15:38:34 +01:00
|
|
|
timestampMin,
|
2021-03-17 17:56:37 +01:00
|
|
|
} from "@gnu-taler/taler-util";
|
2020-08-03 09:30:48 +02:00
|
|
|
import { URL } from "../util/url";
|
2021-02-08 15:38:34 +01:00
|
|
|
import { guardOperationException } from "./errors";
|
|
|
|
import { updateExchangeFromUrl } from "./exchanges";
|
|
|
|
import { EXCHANGE_COINS_LOCK, InternalWalletState } from "./state";
|
|
|
|
import { isWithdrawableDenom, selectWithdrawalDenominations } from "./withdraw";
|
2021-03-17 17:56:37 +01:00
|
|
|
import { RefreshNewDenomInfo } from "../crypto/cryptoTypes.js";
|
2019-12-02 00:42:40 +01:00
|
|
|
|
|
|
|
const logger = new Logger("refresh.ts");
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the amount that we lose when refreshing a coin of the given denomination
|
|
|
|
* with a certain amount left.
|
|
|
|
*
|
|
|
|
* If the amount left is zero, then the refresh cost
|
|
|
|
* is also considered to be zero. If a refresh isn't possible (e.g. due to lack of
|
|
|
|
* the right denominations), then the cost is the full amount left.
|
|
|
|
*
|
|
|
|
* Considers refresh fees, withdrawal fees after refresh and amounts too small
|
|
|
|
* to refresh.
|
|
|
|
*/
|
|
|
|
export function getTotalRefreshCost(
|
|
|
|
denoms: DenominationRecord[],
|
|
|
|
refreshedDenom: DenominationRecord,
|
|
|
|
amountLeft: AmountJson,
|
|
|
|
): AmountJson {
|
|
|
|
const withdrawAmount = Amounts.sub(amountLeft, refreshedDenom.feeRefresh)
|
|
|
|
.amount;
|
2020-12-16 17:59:04 +01:00
|
|
|
const withdrawDenoms = selectWithdrawalDenominations(withdrawAmount, denoms);
|
2019-12-02 00:42:40 +01:00
|
|
|
const resultingAmount = Amounts.add(
|
|
|
|
Amounts.getZero(withdrawAmount.currency),
|
2020-05-11 14:33:25 +02:00
|
|
|
...withdrawDenoms.selectedDenoms.map(
|
|
|
|
(d) => Amounts.mult(d.denom.value, d.count).amount,
|
|
|
|
),
|
2019-12-02 00:42:40 +01:00
|
|
|
).amount;
|
|
|
|
const totalCost = Amounts.sub(amountLeft, resultingAmount).amount;
|
|
|
|
logger.trace(
|
2020-05-15 19:24:39 +02:00
|
|
|
`total refresh cost for ${amountToPretty(amountLeft)} is ${amountToPretty(
|
|
|
|
totalCost,
|
|
|
|
)}`,
|
2019-12-02 00:42:40 +01:00
|
|
|
);
|
|
|
|
return totalCost;
|
|
|
|
}
|
|
|
|
|
2019-12-15 16:59:00 +01:00
|
|
|
/**
|
|
|
|
* Create a refresh session inside a refresh group.
|
|
|
|
*/
|
|
|
|
async function refreshCreateSession(
|
|
|
|
ws: InternalWalletState,
|
|
|
|
refreshGroupId: string,
|
|
|
|
coinIndex: number,
|
|
|
|
): Promise<void> {
|
|
|
|
logger.trace(
|
|
|
|
`creating refresh session for coin ${coinIndex} in refresh group ${refreshGroupId}`,
|
|
|
|
);
|
|
|
|
const refreshGroup = await ws.db.get(Stores.refreshGroups, refreshGroupId);
|
|
|
|
if (!refreshGroup) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (refreshGroup.finishedPerCoin[coinIndex]) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const existingRefreshSession = refreshGroup.refreshSessionPerCoin[coinIndex];
|
|
|
|
if (existingRefreshSession) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const oldCoinPub = refreshGroup.oldCoinPubs[coinIndex];
|
|
|
|
const coin = await ws.db.get(Stores.coins, oldCoinPub);
|
|
|
|
if (!coin) {
|
|
|
|
throw Error("Can't refresh, coin not found");
|
|
|
|
}
|
|
|
|
|
|
|
|
const exchange = await updateExchangeFromUrl(ws, coin.exchangeBaseUrl);
|
|
|
|
if (!exchange) {
|
|
|
|
throw Error("db inconsistent: exchange of coin not found");
|
|
|
|
}
|
|
|
|
|
|
|
|
const oldDenom = await ws.db.get(Stores.denominations, [
|
|
|
|
exchange.baseUrl,
|
2020-09-08 17:33:10 +02:00
|
|
|
coin.denomPubHash,
|
2019-12-15 16:59:00 +01:00
|
|
|
]);
|
|
|
|
|
|
|
|
if (!oldDenom) {
|
|
|
|
throw Error("db inconsistent: denomination for coin not found");
|
|
|
|
}
|
|
|
|
|
|
|
|
const availableDenoms: DenominationRecord[] = await ws.db
|
|
|
|
.iterIndex(Stores.denominations.exchangeBaseUrlIndex, exchange.baseUrl)
|
|
|
|
.toArray();
|
|
|
|
|
2020-09-01 19:31:44 +02:00
|
|
|
const availableAmount = Amounts.sub(
|
|
|
|
refreshGroup.inputPerCoin[coinIndex],
|
|
|
|
oldDenom.feeRefresh,
|
|
|
|
).amount;
|
2019-12-15 16:59:00 +01:00
|
|
|
|
2021-01-13 00:51:30 +01:00
|
|
|
const newCoinDenoms = selectWithdrawalDenominations(
|
|
|
|
availableAmount,
|
|
|
|
availableDenoms,
|
|
|
|
);
|
2019-12-15 16:59:00 +01:00
|
|
|
|
2020-05-11 14:33:25 +02:00
|
|
|
if (newCoinDenoms.selectedDenoms.length === 0) {
|
2019-12-15 16:59:00 +01:00
|
|
|
logger.trace(
|
|
|
|
`not refreshing, available amount ${amountToPretty(
|
|
|
|
availableAmount,
|
|
|
|
)} too small`,
|
|
|
|
);
|
|
|
|
await ws.db.runWithWriteTransaction(
|
|
|
|
[Stores.coins, Stores.refreshGroups],
|
2020-03-30 12:39:32 +02:00
|
|
|
async (tx) => {
|
2019-12-15 16:59:00 +01:00
|
|
|
const rg = await tx.get(Stores.refreshGroups, refreshGroupId);
|
|
|
|
if (!rg) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
rg.finishedPerCoin[coinIndex] = true;
|
2019-12-16 21:10:57 +01:00
|
|
|
let allDone = true;
|
|
|
|
for (const f of rg.finishedPerCoin) {
|
|
|
|
if (!f) {
|
|
|
|
allDone = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (allDone) {
|
|
|
|
rg.timestampFinished = getTimestampNow();
|
|
|
|
rg.retryInfo = initRetryInfo(false);
|
|
|
|
}
|
2019-12-15 16:59:00 +01:00
|
|
|
await tx.put(Stores.refreshGroups, rg);
|
|
|
|
},
|
|
|
|
);
|
2019-12-16 21:10:57 +01:00
|
|
|
ws.notify({ type: NotificationType.RefreshUnwarranted });
|
2019-12-15 16:59:00 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-12-14 16:44:42 +01:00
|
|
|
const sessionSecretSeed = encodeCrock(getRandomBytes(64));
|
2019-12-15 16:59:00 +01:00
|
|
|
|
2020-09-01 19:31:44 +02:00
|
|
|
// Store refresh session for this coin in the database.
|
2019-12-15 16:59:00 +01:00
|
|
|
await ws.db.runWithWriteTransaction(
|
|
|
|
[Stores.refreshGroups, Stores.coins],
|
2020-03-30 12:39:32 +02:00
|
|
|
async (tx) => {
|
2019-12-15 16:59:00 +01:00
|
|
|
const rg = await tx.get(Stores.refreshGroups, refreshGroupId);
|
|
|
|
if (!rg) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (rg.refreshSessionPerCoin[coinIndex]) {
|
|
|
|
return;
|
|
|
|
}
|
2020-12-14 16:44:42 +01:00
|
|
|
rg.refreshSessionPerCoin[coinIndex] = {
|
|
|
|
norevealIndex: undefined,
|
|
|
|
sessionSecretSeed: sessionSecretSeed,
|
|
|
|
newDenoms: newCoinDenoms.selectedDenoms.map((x) => ({
|
|
|
|
count: x.count,
|
|
|
|
denomPubHash: x.denom.denomPubHash,
|
|
|
|
})),
|
|
|
|
amountRefreshOutput: newCoinDenoms.totalCoinValue,
|
|
|
|
};
|
2019-12-15 16:59:00 +01:00
|
|
|
await tx.put(Stores.refreshGroups, rg);
|
|
|
|
},
|
|
|
|
);
|
|
|
|
logger.info(
|
|
|
|
`created refresh session for coin #${coinIndex} in ${refreshGroupId}`,
|
|
|
|
);
|
|
|
|
ws.notify({ type: NotificationType.RefreshStarted });
|
|
|
|
}
|
|
|
|
|
2020-08-20 12:57:20 +02:00
|
|
|
function getRefreshRequestTimeout(rg: RefreshGroupRecord): Duration {
|
|
|
|
return { d_ms: 5000 };
|
|
|
|
}
|
|
|
|
|
2019-12-02 00:42:40 +01:00
|
|
|
async function refreshMelt(
|
|
|
|
ws: InternalWalletState,
|
2019-12-15 16:59:00 +01:00
|
|
|
refreshGroupId: string,
|
|
|
|
coinIndex: number,
|
2019-12-02 00:42:40 +01:00
|
|
|
): Promise<void> {
|
2019-12-15 16:59:00 +01:00
|
|
|
const refreshGroup = await ws.db.get(Stores.refreshGroups, refreshGroupId);
|
|
|
|
if (!refreshGroup) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const refreshSession = refreshGroup.refreshSessionPerCoin[coinIndex];
|
2019-12-02 00:42:40 +01:00
|
|
|
if (!refreshSession) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (refreshSession.norevealIndex !== undefined) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-12-14 16:44:42 +01:00
|
|
|
const oldCoin = await ws.db.get(
|
|
|
|
Stores.coins,
|
|
|
|
refreshGroup.oldCoinPubs[coinIndex],
|
|
|
|
);
|
|
|
|
checkDbInvariant(!!oldCoin, "melt coin doesn't exist");
|
|
|
|
const oldDenom = await ws.db.get(Stores.denominations, [
|
|
|
|
oldCoin.exchangeBaseUrl,
|
|
|
|
oldCoin.denomPubHash,
|
|
|
|
]);
|
|
|
|
checkDbInvariant(!!oldDenom, "denomination for melted coin doesn't exist");
|
|
|
|
|
|
|
|
const newCoinDenoms: RefreshNewDenomInfo[] = [];
|
2019-12-02 00:42:40 +01:00
|
|
|
|
2020-12-14 16:44:42 +01:00
|
|
|
for (const dh of refreshSession.newDenoms) {
|
|
|
|
const newDenom = await ws.db.get(Stores.denominations, [
|
|
|
|
oldCoin.exchangeBaseUrl,
|
|
|
|
dh.denomPubHash,
|
|
|
|
]);
|
|
|
|
checkDbInvariant(
|
|
|
|
!!newDenom,
|
|
|
|
"new denomination for refresh not in database",
|
|
|
|
);
|
|
|
|
newCoinDenoms.push({
|
|
|
|
count: dh.count,
|
|
|
|
denomPub: newDenom.denomPub,
|
|
|
|
feeWithdraw: newDenom.feeWithdraw,
|
|
|
|
value: newDenom.value,
|
|
|
|
});
|
2019-12-02 00:42:40 +01:00
|
|
|
}
|
|
|
|
|
2020-12-14 16:44:42 +01:00
|
|
|
const derived = await ws.cryptoApi.deriveRefreshSession({
|
|
|
|
kappa: 3,
|
|
|
|
meltCoinDenomPubHash: oldCoin.denomPubHash,
|
|
|
|
meltCoinPriv: oldCoin.coinPriv,
|
|
|
|
meltCoinPub: oldCoin.coinPub,
|
|
|
|
feeRefresh: oldDenom.feeRefresh,
|
|
|
|
newCoinDenoms,
|
|
|
|
sessionSecretSeed: refreshSession.sessionSecretSeed,
|
|
|
|
});
|
|
|
|
|
2020-03-09 12:07:46 +01:00
|
|
|
const reqUrl = new URL(
|
2020-12-14 16:44:42 +01:00
|
|
|
`coins/${oldCoin.coinPub}/melt`,
|
|
|
|
oldCoin.exchangeBaseUrl,
|
2020-03-09 12:07:46 +01:00
|
|
|
);
|
2019-12-02 00:42:40 +01:00
|
|
|
const meltReq = {
|
2020-12-14 16:44:42 +01:00
|
|
|
coin_pub: oldCoin.coinPub,
|
|
|
|
confirm_sig: derived.confirmSig,
|
|
|
|
denom_pub_hash: oldCoin.denomPubHash,
|
|
|
|
denom_sig: oldCoin.denomSig,
|
|
|
|
rc: derived.hash,
|
|
|
|
value_with_fee: Amounts.stringify(derived.meltValueWithFee),
|
2019-12-02 00:42:40 +01:00
|
|
|
};
|
2020-01-19 20:41:51 +01:00
|
|
|
logger.trace(`melt request for coin:`, meltReq);
|
2020-08-18 14:53:06 +02:00
|
|
|
|
2020-08-20 12:57:20 +02:00
|
|
|
const resp = await ws.runSequentialized([EXCHANGE_COINS_LOCK], async () => {
|
|
|
|
return await ws.http.postJson(reqUrl.href, meltReq, {
|
|
|
|
timeout: getRefreshRequestTimeout(refreshGroup),
|
|
|
|
});
|
|
|
|
});
|
2020-08-18 14:53:06 +02:00
|
|
|
|
2020-07-22 10:52:03 +02:00
|
|
|
const meltResponse = await readSuccessResponseJsonOrThrow(
|
|
|
|
resp,
|
|
|
|
codecForExchangeMeltResponse(),
|
|
|
|
);
|
2019-12-02 00:42:40 +01:00
|
|
|
|
2020-07-22 10:52:03 +02:00
|
|
|
const norevealIndex = meltResponse.noreveal_index;
|
2019-12-02 00:42:40 +01:00
|
|
|
|
|
|
|
refreshSession.norevealIndex = norevealIndex;
|
|
|
|
|
2020-03-30 12:39:32 +02:00
|
|
|
await ws.db.mutate(Stores.refreshGroups, refreshGroupId, (rg) => {
|
2019-12-15 16:59:00 +01:00
|
|
|
const rs = rg.refreshSessionPerCoin[coinIndex];
|
2020-12-14 16:44:42 +01:00
|
|
|
if (rg.timestampFinished) {
|
2019-12-15 16:59:00 +01:00
|
|
|
return;
|
|
|
|
}
|
2020-12-14 16:44:42 +01:00
|
|
|
if (!rs) {
|
2019-12-02 00:42:40 +01:00
|
|
|
return;
|
|
|
|
}
|
2020-12-14 16:44:42 +01:00
|
|
|
if (rs.norevealIndex !== undefined) {
|
2019-12-02 00:42:40 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
rs.norevealIndex = norevealIndex;
|
2019-12-15 16:59:00 +01:00
|
|
|
return rg;
|
2019-12-02 00:42:40 +01:00
|
|
|
});
|
|
|
|
|
2019-12-05 19:38:19 +01:00
|
|
|
ws.notify({
|
|
|
|
type: NotificationType.RefreshMelted,
|
|
|
|
});
|
2019-12-02 00:42:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
async function refreshReveal(
|
|
|
|
ws: InternalWalletState,
|
2019-12-15 16:59:00 +01:00
|
|
|
refreshGroupId: string,
|
|
|
|
coinIndex: number,
|
2019-12-02 00:42:40 +01:00
|
|
|
): Promise<void> {
|
2019-12-15 16:59:00 +01:00
|
|
|
const refreshGroup = await ws.db.get(Stores.refreshGroups, refreshGroupId);
|
|
|
|
if (!refreshGroup) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const refreshSession = refreshGroup.refreshSessionPerCoin[coinIndex];
|
2019-12-02 00:42:40 +01:00
|
|
|
if (!refreshSession) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const norevealIndex = refreshSession.norevealIndex;
|
|
|
|
if (norevealIndex === undefined) {
|
|
|
|
throw Error("can't reveal without melting first");
|
|
|
|
}
|
2020-12-14 16:44:42 +01:00
|
|
|
|
|
|
|
const oldCoin = await ws.db.get(
|
|
|
|
Stores.coins,
|
|
|
|
refreshGroup.oldCoinPubs[coinIndex],
|
|
|
|
);
|
|
|
|
checkDbInvariant(!!oldCoin, "melt coin doesn't exist");
|
|
|
|
const oldDenom = await ws.db.get(Stores.denominations, [
|
|
|
|
oldCoin.exchangeBaseUrl,
|
|
|
|
oldCoin.denomPubHash,
|
|
|
|
]);
|
|
|
|
checkDbInvariant(!!oldDenom, "denomination for melted coin doesn't exist");
|
|
|
|
|
|
|
|
const newCoinDenoms: RefreshNewDenomInfo[] = [];
|
|
|
|
|
|
|
|
for (const dh of refreshSession.newDenoms) {
|
|
|
|
const newDenom = await ws.db.get(Stores.denominations, [
|
|
|
|
oldCoin.exchangeBaseUrl,
|
|
|
|
dh.denomPubHash,
|
|
|
|
]);
|
|
|
|
checkDbInvariant(
|
|
|
|
!!newDenom,
|
|
|
|
"new denomination for refresh not in database",
|
|
|
|
);
|
|
|
|
newCoinDenoms.push({
|
|
|
|
count: dh.count,
|
|
|
|
denomPub: newDenom.denomPub,
|
|
|
|
feeWithdraw: newDenom.feeWithdraw,
|
|
|
|
value: newDenom.value,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
const derived = await ws.cryptoApi.deriveRefreshSession({
|
|
|
|
kappa: 3,
|
|
|
|
meltCoinDenomPubHash: oldCoin.denomPubHash,
|
|
|
|
meltCoinPriv: oldCoin.coinPriv,
|
|
|
|
meltCoinPub: oldCoin.coinPub,
|
|
|
|
feeRefresh: oldDenom.feeRefresh,
|
|
|
|
newCoinDenoms,
|
|
|
|
sessionSecretSeed: refreshSession.sessionSecretSeed,
|
|
|
|
});
|
|
|
|
|
|
|
|
const privs = Array.from(derived.transferPrivs);
|
2019-12-02 00:42:40 +01:00
|
|
|
privs.splice(norevealIndex, 1);
|
|
|
|
|
2020-12-14 16:44:42 +01:00
|
|
|
const planchets = derived.planchetsForGammas[norevealIndex];
|
2019-12-02 00:42:40 +01:00
|
|
|
if (!planchets) {
|
|
|
|
throw Error("refresh index error");
|
|
|
|
}
|
|
|
|
|
2019-12-12 22:39:45 +01:00
|
|
|
const meltCoinRecord = await ws.db.get(
|
2019-12-02 00:42:40 +01:00
|
|
|
Stores.coins,
|
2020-12-14 16:44:42 +01:00
|
|
|
refreshGroup.oldCoinPubs[coinIndex],
|
2019-12-02 00:42:40 +01:00
|
|
|
);
|
|
|
|
if (!meltCoinRecord) {
|
|
|
|
throw Error("inconsistent database");
|
|
|
|
}
|
|
|
|
|
2020-09-08 16:59:47 +02:00
|
|
|
const evs = planchets.map((x: RefreshPlanchet) => x.coinEv);
|
2020-12-14 16:44:42 +01:00
|
|
|
const newDenomsFlat: string[] = [];
|
2019-12-02 00:42:40 +01:00
|
|
|
const linkSigs: string[] = [];
|
2020-12-14 16:44:42 +01:00
|
|
|
|
2019-12-02 00:42:40 +01:00
|
|
|
for (let i = 0; i < refreshSession.newDenoms.length; i++) {
|
2020-12-14 16:44:42 +01:00
|
|
|
const dsel = refreshSession.newDenoms[i];
|
|
|
|
for (let j = 0; j < dsel.count; j++) {
|
|
|
|
const newCoinIndex = linkSigs.length;
|
|
|
|
const linkSig = await ws.cryptoApi.signCoinLink(
|
|
|
|
meltCoinRecord.coinPriv,
|
|
|
|
dsel.denomPubHash,
|
|
|
|
meltCoinRecord.coinPub,
|
|
|
|
derived.transferPubs[norevealIndex],
|
|
|
|
planchets[newCoinIndex].coinEv,
|
|
|
|
);
|
|
|
|
linkSigs.push(linkSig);
|
|
|
|
newDenomsFlat.push(dsel.denomPubHash);
|
|
|
|
}
|
2019-12-02 00:42:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
const req = {
|
|
|
|
coin_evs: evs,
|
2020-12-14 16:44:42 +01:00
|
|
|
new_denoms_h: newDenomsFlat,
|
|
|
|
rc: derived.hash,
|
2019-12-02 00:42:40 +01:00
|
|
|
transfer_privs: privs,
|
2020-12-14 16:44:42 +01:00
|
|
|
transfer_pub: derived.transferPubs[norevealIndex],
|
2019-12-02 00:42:40 +01:00
|
|
|
link_sigs: linkSigs,
|
|
|
|
};
|
|
|
|
|
2020-03-09 12:07:46 +01:00
|
|
|
const reqUrl = new URL(
|
2020-12-14 16:44:42 +01:00
|
|
|
`refreshes/${derived.hash}/reveal`,
|
|
|
|
oldCoin.exchangeBaseUrl,
|
2020-03-09 12:07:46 +01:00
|
|
|
);
|
2019-12-02 00:42:40 +01:00
|
|
|
|
2020-08-20 12:57:20 +02:00
|
|
|
const resp = await ws.runSequentialized([EXCHANGE_COINS_LOCK], async () => {
|
|
|
|
return await ws.http.postJson(reqUrl.href, req, {
|
|
|
|
timeout: getRefreshRequestTimeout(refreshGroup),
|
|
|
|
});
|
|
|
|
});
|
2020-08-18 14:53:06 +02:00
|
|
|
|
2020-07-22 10:52:03 +02:00
|
|
|
const reveal = await readSuccessResponseJsonOrThrow(
|
|
|
|
resp,
|
|
|
|
codecForExchangeRevealResponse(),
|
|
|
|
);
|
2019-12-02 00:42:40 +01:00
|
|
|
|
|
|
|
const coins: CoinRecord[] = [];
|
|
|
|
|
2020-12-14 16:44:42 +01:00
|
|
|
for (let i = 0; i < refreshSession.newDenoms.length; i++) {
|
|
|
|
for (let j = 0; j < refreshSession.newDenoms[i].count; j++) {
|
|
|
|
const newCoinIndex = coins.length;
|
|
|
|
const denom = await ws.db.get(Stores.denominations, [
|
|
|
|
oldCoin.exchangeBaseUrl,
|
|
|
|
refreshSession.newDenoms[i].denomPubHash,
|
|
|
|
]);
|
|
|
|
if (!denom) {
|
|
|
|
console.error("denom not found");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
const pc = derived.planchetsForGammas[norevealIndex][newCoinIndex];
|
|
|
|
const denomSig = await ws.cryptoApi.rsaUnblind(
|
|
|
|
reveal.ev_sigs[newCoinIndex].ev_sig,
|
|
|
|
pc.blindingKey,
|
|
|
|
denom.denomPub,
|
|
|
|
);
|
|
|
|
const coin: CoinRecord = {
|
|
|
|
blindingKey: pc.blindingKey,
|
|
|
|
coinPriv: pc.privateKey,
|
|
|
|
coinPub: pc.publicKey,
|
|
|
|
currentAmount: denom.value,
|
|
|
|
denomPub: denom.denomPub,
|
|
|
|
denomPubHash: denom.denomPubHash,
|
|
|
|
denomSig,
|
|
|
|
exchangeBaseUrl: oldCoin.exchangeBaseUrl,
|
|
|
|
status: CoinStatus.Fresh,
|
|
|
|
coinSource: {
|
|
|
|
type: CoinSourceType.Refresh,
|
|
|
|
oldCoinPub: refreshGroup.oldCoinPubs[coinIndex],
|
|
|
|
},
|
|
|
|
suspended: false,
|
2020-12-16 17:59:04 +01:00
|
|
|
coinEvHash: pc.coinEv,
|
2020-12-14 16:44:42 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
coins.push(coin);
|
2019-12-02 00:42:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-12 22:39:45 +01:00
|
|
|
await ws.db.runWithWriteTransaction(
|
2019-12-15 16:59:00 +01:00
|
|
|
[Stores.coins, Stores.refreshGroups],
|
2020-03-30 12:39:32 +02:00
|
|
|
async (tx) => {
|
2019-12-15 16:59:00 +01:00
|
|
|
const rg = await tx.get(Stores.refreshGroups, refreshGroupId);
|
|
|
|
if (!rg) {
|
2020-08-14 12:23:50 +02:00
|
|
|
logger.warn("no refresh session found");
|
2019-12-02 00:42:40 +01:00
|
|
|
return;
|
|
|
|
}
|
2019-12-15 16:59:00 +01:00
|
|
|
const rs = rg.refreshSessionPerCoin[coinIndex];
|
|
|
|
if (!rs) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
rg.finishedPerCoin[coinIndex] = true;
|
|
|
|
let allDone = true;
|
|
|
|
for (const f of rg.finishedPerCoin) {
|
|
|
|
if (!f) {
|
|
|
|
allDone = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (allDone) {
|
2019-12-16 16:20:45 +01:00
|
|
|
rg.timestampFinished = getTimestampNow();
|
2019-12-15 16:59:00 +01:00
|
|
|
rg.retryInfo = initRetryInfo(false);
|
|
|
|
}
|
2020-04-06 17:45:41 +02:00
|
|
|
for (const coin of coins) {
|
2019-12-02 00:42:40 +01:00
|
|
|
await tx.put(Stores.coins, coin);
|
|
|
|
}
|
2019-12-15 16:59:00 +01:00
|
|
|
await tx.put(Stores.refreshGroups, rg);
|
2019-12-02 00:42:40 +01:00
|
|
|
},
|
|
|
|
);
|
2020-08-14 12:23:50 +02:00
|
|
|
logger.trace("refresh finished (end of reveal)");
|
2019-12-05 19:38:19 +01:00
|
|
|
ws.notify({
|
|
|
|
type: NotificationType.RefreshRevealed,
|
|
|
|
});
|
2019-12-02 00:42:40 +01:00
|
|
|
}
|
|
|
|
|
2019-12-05 19:38:19 +01:00
|
|
|
async function incrementRefreshRetry(
|
|
|
|
ws: InternalWalletState,
|
2019-12-15 16:59:00 +01:00
|
|
|
refreshGroupId: string,
|
2020-09-01 14:57:22 +02:00
|
|
|
err: TalerErrorDetails | undefined,
|
2019-12-05 19:38:19 +01:00
|
|
|
): Promise<void> {
|
2020-03-30 12:39:32 +02:00
|
|
|
await ws.db.runWithWriteTransaction([Stores.refreshGroups], async (tx) => {
|
2019-12-15 16:59:00 +01:00
|
|
|
const r = await tx.get(Stores.refreshGroups, refreshGroupId);
|
2019-12-05 19:38:19 +01:00
|
|
|
if (!r) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!r.retryInfo) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
r.retryInfo.retryCounter++;
|
|
|
|
updateRetryInfoTimeout(r.retryInfo);
|
|
|
|
r.lastError = err;
|
2019-12-15 16:59:00 +01:00
|
|
|
await tx.put(Stores.refreshGroups, r);
|
2019-12-05 19:38:19 +01:00
|
|
|
});
|
2020-07-22 10:52:03 +02:00
|
|
|
if (err) {
|
|
|
|
ws.notify({ type: NotificationType.RefreshOperationError, error: err });
|
|
|
|
}
|
2019-12-05 19:38:19 +01:00
|
|
|
}
|
|
|
|
|
2020-08-18 14:53:06 +02:00
|
|
|
/**
|
|
|
|
* Actually process a refresh group that has been created.
|
|
|
|
*/
|
2019-12-15 16:59:00 +01:00
|
|
|
export async function processRefreshGroup(
|
2019-12-02 00:42:40 +01:00
|
|
|
ws: InternalWalletState,
|
2019-12-15 16:59:00 +01:00
|
|
|
refreshGroupId: string,
|
2020-04-06 17:45:41 +02:00
|
|
|
forceNow = false,
|
2019-12-15 16:59:00 +01:00
|
|
|
): Promise<void> {
|
|
|
|
await ws.memoProcessRefresh.memo(refreshGroupId, async () => {
|
2020-09-01 14:57:22 +02:00
|
|
|
const onOpErr = (e: TalerErrorDetails): Promise<void> =>
|
2019-12-15 16:59:00 +01:00
|
|
|
incrementRefreshRetry(ws, refreshGroupId, e);
|
|
|
|
return await guardOperationException(
|
|
|
|
async () => await processRefreshGroupImpl(ws, refreshGroupId, forceNow),
|
2019-12-05 19:38:19 +01:00
|
|
|
onOpErr,
|
|
|
|
);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-12-15 16:59:00 +01:00
|
|
|
async function resetRefreshGroupRetry(
|
2019-12-07 22:02:11 +01:00
|
|
|
ws: InternalWalletState,
|
|
|
|
refreshSessionId: string,
|
2020-04-07 10:07:32 +02:00
|
|
|
): Promise<void> {
|
2020-03-30 12:39:32 +02:00
|
|
|
await ws.db.mutate(Stores.refreshGroups, refreshSessionId, (x) => {
|
2019-12-07 22:02:11 +01:00
|
|
|
if (x.retryInfo.active) {
|
|
|
|
x.retryInfo = initRetryInfo();
|
|
|
|
}
|
|
|
|
return x;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-12-15 16:59:00 +01:00
|
|
|
async function processRefreshGroupImpl(
|
2019-12-05 19:38:19 +01:00
|
|
|
ws: InternalWalletState,
|
2019-12-15 16:59:00 +01:00
|
|
|
refreshGroupId: string,
|
2019-12-07 22:02:11 +01:00
|
|
|
forceNow: boolean,
|
2020-04-07 10:07:32 +02:00
|
|
|
): Promise<void> {
|
2019-12-07 22:02:11 +01:00
|
|
|
if (forceNow) {
|
2019-12-15 16:59:00 +01:00
|
|
|
await resetRefreshGroupRetry(ws, refreshGroupId);
|
2019-12-07 22:02:11 +01:00
|
|
|
}
|
2019-12-15 16:59:00 +01:00
|
|
|
const refreshGroup = await ws.db.get(Stores.refreshGroups, refreshGroupId);
|
|
|
|
if (!refreshGroup) {
|
2019-12-02 00:42:40 +01:00
|
|
|
return;
|
|
|
|
}
|
2019-12-16 16:20:45 +01:00
|
|
|
if (refreshGroup.timestampFinished) {
|
2019-12-02 00:42:40 +01:00
|
|
|
return;
|
|
|
|
}
|
2019-12-15 16:59:00 +01:00
|
|
|
const ps = refreshGroup.oldCoinPubs.map((x, i) =>
|
|
|
|
processRefreshSession(ws, refreshGroupId, i),
|
|
|
|
);
|
|
|
|
await Promise.all(ps);
|
2019-12-02 00:42:40 +01:00
|
|
|
logger.trace("refresh finished");
|
|
|
|
}
|
|
|
|
|
2019-12-15 16:59:00 +01:00
|
|
|
async function processRefreshSession(
|
2019-12-02 00:42:40 +01:00
|
|
|
ws: InternalWalletState,
|
2019-12-15 16:59:00 +01:00
|
|
|
refreshGroupId: string,
|
|
|
|
coinIndex: number,
|
2020-04-07 10:07:32 +02:00
|
|
|
): Promise<void> {
|
2020-03-09 12:07:46 +01:00
|
|
|
logger.trace(
|
|
|
|
`processing refresh session for coin ${coinIndex} of group ${refreshGroupId}`,
|
|
|
|
);
|
2019-12-15 16:59:00 +01:00
|
|
|
let refreshGroup = await ws.db.get(Stores.refreshGroups, refreshGroupId);
|
|
|
|
if (!refreshGroup) {
|
2019-12-02 00:42:40 +01:00
|
|
|
return;
|
|
|
|
}
|
2019-12-15 16:59:00 +01:00
|
|
|
if (refreshGroup.finishedPerCoin[coinIndex]) {
|
|
|
|
return;
|
2019-12-02 00:42:40 +01:00
|
|
|
}
|
2019-12-15 16:59:00 +01:00
|
|
|
if (!refreshGroup.refreshSessionPerCoin[coinIndex]) {
|
|
|
|
await refreshCreateSession(ws, refreshGroupId, coinIndex);
|
|
|
|
refreshGroup = await ws.db.get(Stores.refreshGroups, refreshGroupId);
|
|
|
|
if (!refreshGroup) {
|
|
|
|
return;
|
|
|
|
}
|
2019-12-02 00:42:40 +01:00
|
|
|
}
|
2019-12-15 16:59:00 +01:00
|
|
|
const refreshSession = refreshGroup.refreshSessionPerCoin[coinIndex];
|
|
|
|
if (!refreshSession) {
|
|
|
|
if (!refreshGroup.finishedPerCoin[coinIndex]) {
|
|
|
|
throw Error(
|
|
|
|
"BUG: refresh session was not created and coin not marked as finished",
|
|
|
|
);
|
|
|
|
}
|
2019-12-02 00:42:40 +01:00
|
|
|
return;
|
|
|
|
}
|
2019-12-15 16:59:00 +01:00
|
|
|
if (refreshSession.norevealIndex === undefined) {
|
|
|
|
await refreshMelt(ws, refreshGroupId, coinIndex);
|
|
|
|
}
|
|
|
|
await refreshReveal(ws, refreshGroupId, coinIndex);
|
|
|
|
}
|
2019-12-02 00:42:40 +01:00
|
|
|
|
2019-12-15 16:59:00 +01:00
|
|
|
/**
|
|
|
|
* Create a refresh group for a list of coins.
|
2020-09-01 19:31:44 +02:00
|
|
|
*
|
|
|
|
* Refreshes the remaining amount on the coin, effectively capturing the remaining
|
|
|
|
* value in the refresh group.
|
|
|
|
*
|
|
|
|
* The caller must ensure that
|
|
|
|
* the remaining amount was updated correctly before the coin was deposited or
|
|
|
|
* credited.
|
|
|
|
*
|
|
|
|
* The caller must also ensure that the coins that should be refreshed exist
|
|
|
|
* in the current database transaction.
|
2019-12-15 16:59:00 +01:00
|
|
|
*/
|
|
|
|
export async function createRefreshGroup(
|
2020-07-23 14:05:17 +02:00
|
|
|
ws: InternalWalletState,
|
2020-11-27 11:23:06 +01:00
|
|
|
tx: TransactionHandle<
|
|
|
|
| typeof Stores.denominations
|
|
|
|
| typeof Stores.coins
|
|
|
|
| typeof Stores.refreshGroups
|
|
|
|
>,
|
2019-12-15 16:59:00 +01:00
|
|
|
oldCoinPubs: CoinPublicKey[],
|
|
|
|
reason: RefreshReason,
|
|
|
|
): Promise<RefreshGroupId> {
|
|
|
|
const refreshGroupId = encodeCrock(getRandomBytes(32));
|
|
|
|
|
2020-09-01 19:31:44 +02:00
|
|
|
const inputPerCoin: AmountJson[] = [];
|
|
|
|
const estimatedOutputPerCoin: AmountJson[] = [];
|
|
|
|
|
|
|
|
const denomsPerExchange: Record<string, DenominationRecord[]> = {};
|
|
|
|
|
|
|
|
const getDenoms = async (
|
|
|
|
exchangeBaseUrl: string,
|
|
|
|
): Promise<DenominationRecord[]> => {
|
|
|
|
if (denomsPerExchange[exchangeBaseUrl]) {
|
|
|
|
return denomsPerExchange[exchangeBaseUrl];
|
|
|
|
}
|
|
|
|
const allDenoms = await tx
|
|
|
|
.iterIndexed(Stores.denominations.exchangeBaseUrlIndex, exchangeBaseUrl)
|
|
|
|
.filter((x) => {
|
|
|
|
return isWithdrawableDenom(x);
|
|
|
|
});
|
|
|
|
denomsPerExchange[exchangeBaseUrl] = allDenoms;
|
|
|
|
return allDenoms;
|
|
|
|
};
|
|
|
|
|
|
|
|
for (const ocp of oldCoinPubs) {
|
|
|
|
const coin = await tx.get(Stores.coins, ocp.coinPub);
|
|
|
|
checkDbInvariant(!!coin, "coin must be in database");
|
|
|
|
const denom = await tx.get(Stores.denominations, [
|
|
|
|
coin.exchangeBaseUrl,
|
2020-09-08 17:33:10 +02:00
|
|
|
coin.denomPubHash,
|
2020-09-01 19:31:44 +02:00
|
|
|
]);
|
|
|
|
checkDbInvariant(
|
|
|
|
!!denom,
|
|
|
|
"denomination for existing coin must be in database",
|
|
|
|
);
|
|
|
|
const refreshAmount = coin.currentAmount;
|
|
|
|
inputPerCoin.push(refreshAmount);
|
|
|
|
coin.currentAmount = Amounts.getZero(refreshAmount.currency);
|
|
|
|
coin.status = CoinStatus.Dormant;
|
|
|
|
await tx.put(Stores.coins, coin);
|
|
|
|
const denoms = await getDenoms(coin.exchangeBaseUrl);
|
|
|
|
const cost = getTotalRefreshCost(denoms, denom, refreshAmount);
|
|
|
|
const output = Amounts.sub(refreshAmount, cost).amount;
|
|
|
|
estimatedOutputPerCoin.push(output);
|
|
|
|
}
|
|
|
|
|
2019-12-15 16:59:00 +01:00
|
|
|
const refreshGroup: RefreshGroupRecord = {
|
2019-12-16 16:20:45 +01:00
|
|
|
timestampFinished: undefined,
|
2020-03-30 12:39:32 +02:00
|
|
|
finishedPerCoin: oldCoinPubs.map((x) => false),
|
2019-12-15 16:59:00 +01:00
|
|
|
lastError: undefined,
|
2019-12-16 12:53:22 +01:00
|
|
|
lastErrorPerCoin: {},
|
2020-03-30 12:39:32 +02:00
|
|
|
oldCoinPubs: oldCoinPubs.map((x) => x.coinPub),
|
2019-12-15 16:59:00 +01:00
|
|
|
reason,
|
|
|
|
refreshGroupId,
|
2020-03-30 12:39:32 +02:00
|
|
|
refreshSessionPerCoin: oldCoinPubs.map((x) => undefined),
|
2019-12-15 16:59:00 +01:00
|
|
|
retryInfo: initRetryInfo(),
|
2020-09-01 19:31:44 +02:00
|
|
|
inputPerCoin,
|
|
|
|
estimatedOutputPerCoin,
|
2020-12-15 17:12:22 +01:00
|
|
|
timestampCreated: getTimestampNow(),
|
2019-12-15 16:59:00 +01:00
|
|
|
};
|
2019-12-02 00:42:40 +01:00
|
|
|
|
2020-08-20 08:29:06 +02:00
|
|
|
if (oldCoinPubs.length == 0) {
|
|
|
|
logger.warn("created refresh group with zero coins");
|
|
|
|
refreshGroup.timestampFinished = getTimestampNow();
|
|
|
|
}
|
|
|
|
|
2019-12-15 16:59:00 +01:00
|
|
|
await tx.put(Stores.refreshGroups, refreshGroup);
|
2020-07-23 14:05:17 +02:00
|
|
|
|
2020-08-18 14:53:06 +02:00
|
|
|
logger.trace(`created refresh group ${refreshGroupId}`);
|
2020-07-23 14:05:17 +02:00
|
|
|
|
2020-08-20 08:29:06 +02:00
|
|
|
processRefreshGroup(ws, refreshGroupId).catch((e) => {
|
|
|
|
logger.warn(`processing refresh group ${refreshGroupId} failed`);
|
|
|
|
});
|
|
|
|
|
2019-12-15 16:59:00 +01:00
|
|
|
return {
|
|
|
|
refreshGroupId,
|
|
|
|
};
|
2019-12-02 00:42:40 +01:00
|
|
|
}
|
2020-09-03 13:59:09 +02:00
|
|
|
|
2020-09-03 17:08:26 +02:00
|
|
|
/**
|
|
|
|
* Timestamp after which the wallet would do the next check for an auto-refresh.
|
|
|
|
*/
|
|
|
|
function getAutoRefreshCheckThreshold(d: DenominationRecord): Timestamp {
|
2020-09-04 08:34:11 +02:00
|
|
|
const delta = timestampDifference(
|
|
|
|
d.stampExpireWithdraw,
|
|
|
|
d.stampExpireDeposit,
|
|
|
|
);
|
2020-09-03 17:08:26 +02:00
|
|
|
const deltaDiv = durationMul(delta, 0.75);
|
|
|
|
return timestampAddDuration(d.stampExpireWithdraw, deltaDiv);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Timestamp after which the wallet would do an auto-refresh.
|
|
|
|
*/
|
|
|
|
function getAutoRefreshExecuteThreshold(d: DenominationRecord): Timestamp {
|
2020-09-04 08:34:11 +02:00
|
|
|
const delta = timestampDifference(
|
|
|
|
d.stampExpireWithdraw,
|
|
|
|
d.stampExpireDeposit,
|
|
|
|
);
|
2020-09-03 17:08:26 +02:00
|
|
|
const deltaDiv = durationMul(delta, 0.5);
|
|
|
|
return timestampAddDuration(d.stampExpireWithdraw, deltaDiv);
|
|
|
|
}
|
|
|
|
|
2020-09-03 13:59:09 +02:00
|
|
|
export async function autoRefresh(
|
|
|
|
ws: InternalWalletState,
|
|
|
|
exchangeBaseUrl: string,
|
2020-09-03 17:08:26 +02:00
|
|
|
): Promise<void> {
|
2020-09-06 15:59:12 +02:00
|
|
|
await updateExchangeFromUrl(ws, exchangeBaseUrl, true);
|
2020-09-03 17:08:26 +02:00
|
|
|
await ws.db.runWithWriteTransaction(
|
|
|
|
[
|
|
|
|
Stores.coins,
|
|
|
|
Stores.denominations,
|
|
|
|
Stores.refreshGroups,
|
|
|
|
Stores.exchanges,
|
|
|
|
],
|
|
|
|
async (tx) => {
|
|
|
|
const exchange = await tx.get(Stores.exchanges, exchangeBaseUrl);
|
|
|
|
if (!exchange) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const coins = await tx
|
|
|
|
.iterIndexed(Stores.coins.exchangeBaseUrlIndex, exchangeBaseUrl)
|
|
|
|
.toArray();
|
|
|
|
const refreshCoins: CoinPublicKey[] = [];
|
|
|
|
for (const coin of coins) {
|
|
|
|
if (coin.status !== CoinStatus.Fresh) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (coin.suspended) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
const denom = await tx.get(Stores.denominations, [
|
|
|
|
exchangeBaseUrl,
|
2020-09-08 17:33:10 +02:00
|
|
|
coin.denomPubHash,
|
2020-09-03 17:08:26 +02:00
|
|
|
]);
|
|
|
|
if (!denom) {
|
|
|
|
logger.warn("denomination not in database");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
const executeThreshold = getAutoRefreshExecuteThreshold(denom);
|
|
|
|
if (isTimestampExpired(executeThreshold)) {
|
|
|
|
refreshCoins.push(coin);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (refreshCoins.length > 0) {
|
|
|
|
await createRefreshGroup(ws, tx, refreshCoins, RefreshReason.Scheduled);
|
|
|
|
}
|
|
|
|
|
|
|
|
const denoms = await tx
|
|
|
|
.iterIndexed(Stores.denominations.exchangeBaseUrlIndex, exchangeBaseUrl)
|
|
|
|
.toArray();
|
|
|
|
let minCheckThreshold = timestampAddDuration(
|
|
|
|
getTimestampNow(),
|
|
|
|
durationFromSpec({ days: 1 }),
|
|
|
|
);
|
|
|
|
for (const denom of denoms) {
|
|
|
|
const checkThreshold = getAutoRefreshCheckThreshold(denom);
|
|
|
|
const executeThreshold = getAutoRefreshExecuteThreshold(denom);
|
|
|
|
if (isTimestampExpired(executeThreshold)) {
|
|
|
|
// No need to consider this denomination, we already did an auto refresh check.
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
minCheckThreshold = timestampMin(minCheckThreshold, checkThreshold);
|
|
|
|
}
|
|
|
|
exchange.nextRefreshCheck = minCheckThreshold;
|
|
|
|
await tx.put(Stores.exchanges, exchange);
|
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|