wallet-core/packages/taler-wallet-core/src/operations/tip.ts

375 lines
10 KiB
TypeScript
Raw Normal View History

/*
This file is part of GNU Taler
2019-12-16 16:59:09 +01:00
(C) 2019 Taler Systems S.A.
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-03-17 17:56:37 +01:00
/**
* Imports.
*/
2019-12-16 16:59:09 +01:00
import {
2022-09-05 18:12:30 +02:00
Amounts,
BlindedDenominationSignature,
codecForMerchantTipResponseV2,
codecForTipPickupGetResponse,
DenomKeyType,
encodeCrock,
getRandomBytes,
j2s,
Logger,
parseTipUri,
PrepareTipResult,
TalerErrorCode,
TalerProtocolTimestamp,
TipPlanchetDetail,
URL,
2021-03-17 17:56:37 +01:00
} from "@gnu-taler/taler-util";
import { DerivedTipPlanchet } from "../crypto/cryptoTypes.js";
2019-12-16 16:59:09 +01:00
import {
2020-09-08 15:57:08 +02:00
CoinRecord,
CoinSourceType,
2022-09-05 18:12:30 +02:00
CoinStatus,
DenominationRecord,
OperationAttemptResult,
OperationAttemptResultType,
TipRecord,
2021-03-17 17:56:37 +01:00
} from "../db.js";
import { makeErrorDetail } from "../errors.js";
import { InternalWalletState } from "../internal-wallet-state.js";
2021-06-14 16:08:58 +02:00
import {
getHttpResponseErrorDetails,
2022-09-05 18:12:30 +02:00
readSuccessResponseJsonOrThrow,
2021-06-14 16:08:58 +02:00
} from "../util/http.js";
import { checkDbInvariant, checkLogicInvariant } from "../util/invariants.js";
import { updateExchangeFromUrl } from "./exchanges.js";
import {
2022-09-05 18:12:30 +02:00
getCandidateWithdrawalDenoms,
getExchangeWithdrawalInfo,
selectWithdrawalDenominations,
updateWithdrawalDenoms,
} from "./withdraw.js";
const logger = new Logger("operations/tip.ts");
2020-09-08 14:10:47 +02:00
export async function prepareTip(
ws: InternalWalletState,
2019-12-16 16:59:09 +01:00
talerTipUri: string,
2020-09-08 14:10:47 +02:00
): Promise<PrepareTipResult> {
const res = parseTipUri(talerTipUri);
if (!res) {
throw Error("invalid taler://tip URI");
}
2021-06-09 15:14:17 +02:00
let tipRecord = await ws.db
.mktx((x) => ({
tips: x.tips,
}))
.runReadOnly(async (tx) => {
return tx.tips.indexes.byMerchantTipIdAndBaseUrl.get([
res.merchantTipId,
res.merchantBaseUrl,
]);
});
if (!tipRecord) {
const tipStatusUrl = new URL(
`tips/${res.merchantTipId}`,
res.merchantBaseUrl,
);
logger.trace("checking tip status from", tipStatusUrl.href);
const merchantResp = await ws.http.get(tipStatusUrl.href);
const tipPickupStatus = await readSuccessResponseJsonOrThrow(
merchantResp,
codecForTipPickupGetResponse(),
);
logger.trace(`status ${j2s(tipPickupStatus)}`);
const amount = Amounts.parseOrThrow(tipPickupStatus.tip_amount);
2020-11-16 14:12:37 +01:00
logger.trace("new tip, creating tip record");
await updateExchangeFromUrl(ws, tipPickupStatus.exchange_url);
//FIXME: is this needed? withdrawDetails is not used
// * if the intention is to update the exchange information in the database
// maybe we can use another name. `get` seems like a pure-function
2019-12-09 19:59:08 +01:00
const withdrawDetails = await getExchangeWithdrawalInfo(
ws,
tipPickupStatus.exchange_url,
amount,
undefined
);
2020-09-08 14:10:47 +02:00
const walletTipId = encodeCrock(getRandomBytes(32));
await updateWithdrawalDenoms(ws, tipPickupStatus.exchange_url);
2021-01-14 18:00:00 +01:00
const denoms = await getCandidateWithdrawalDenoms(
2021-01-06 17:06:19 +01:00
ws,
tipPickupStatus.exchange_url,
);
2021-01-06 17:06:19 +01:00
const selectedDenoms = selectWithdrawalDenominations(amount, denoms);
const secretSeed = encodeCrock(getRandomBytes(64));
const denomSelUid = encodeCrock(getRandomBytes(32));
2022-03-18 15:32:41 +01:00
const newTipRecord: TipRecord = {
2020-09-08 14:10:47 +02:00
walletTipId: walletTipId,
2019-12-16 12:53:22 +01:00
acceptedTimestamp: undefined,
2020-09-08 15:57:08 +02:00
tipAmountRaw: amount,
tipExpiration: tipPickupStatus.expiration,
exchangeBaseUrl: tipPickupStatus.exchange_url,
merchantBaseUrl: res.merchantBaseUrl,
2022-03-18 15:32:41 +01:00
createdTimestamp: TalerProtocolTimestamp.now(),
merchantTipId: res.merchantTipId,
tipAmountEffective: selectedDenoms.totalCoinValue,
denomsSel: selectedDenoms,
pickedUpTimestamp: undefined,
secretSeed,
denomSelUid,
};
2021-06-09 15:14:17 +02:00
await ws.db
.mktx((x) => ({
tips: x.tips,
}))
.runReadWrite(async (tx) => {
await tx.tips.put(newTipRecord);
});
tipRecord = newTipRecord;
}
2020-09-08 14:10:47 +02:00
const tipStatus: PrepareTipResult = {
2019-12-16 12:53:22 +01:00
accepted: !!tipRecord && !!tipRecord.acceptedTimestamp,
tipAmountRaw: Amounts.stringify(tipRecord.tipAmountRaw),
exchangeBaseUrl: tipRecord.exchangeBaseUrl,
merchantBaseUrl: tipRecord.merchantBaseUrl,
expirationTimestamp: tipRecord.tipExpiration,
2020-09-08 15:57:08 +02:00
tipAmountEffective: Amounts.stringify(tipRecord.tipAmountEffective),
2020-09-08 14:10:47 +02:00
walletTipId: tipRecord.walletTipId,
};
return tipStatus;
}
export async function processTip(
2019-12-05 19:38:19 +01:00
ws: InternalWalletState,
2020-09-08 15:57:08 +02:00
walletTipId: string,
options: {
forceNow?: boolean;
} = {},
2022-09-05 18:12:30 +02:00
): Promise<OperationAttemptResult> {
2021-06-09 15:14:17 +02:00
const tipRecord = await ws.db
.mktx((x) => ({
tips: x.tips,
}))
.runReadOnly(async (tx) => {
return tx.tips.get(walletTipId);
});
if (!tipRecord) {
2022-09-05 18:12:30 +02:00
return {
type: OperationAttemptResultType.Finished,
result: undefined,
};
}
if (tipRecord.pickedUpTimestamp) {
logger.warn("tip already picked up");
2022-09-05 18:12:30 +02:00
return {
type: OperationAttemptResultType.Finished,
result: undefined,
};
}
const denomsForWithdraw = tipRecord.denomsSel;
const planchets: DerivedTipPlanchet[] = [];
// Planchets in the form that the merchant expects
const planchetsDetail: TipPlanchetDetail[] = [];
2021-01-06 17:06:19 +01:00
const denomForPlanchet: { [index: number]: DenominationRecord } = [];
for (const dh of denomsForWithdraw.selectedDenoms) {
2021-06-09 15:14:17 +02:00
const denom = await ws.db
.mktx((x) => ({
denominations: x.denominations,
}))
.runReadOnly(async (tx) => {
return tx.denominations.get([
tipRecord.exchangeBaseUrl,
dh.denomPubHash,
]);
});
checkDbInvariant(!!denom, "denomination should be in database");
for (let i = 0; i < dh.count; i++) {
2021-01-06 17:06:19 +01:00
const deriveReq = {
denomPub: denom.denomPub,
planchetIndex: planchets.length,
secretSeed: tipRecord.secretSeed,
2021-01-06 17:06:19 +01:00
};
2021-01-13 00:51:30 +01:00
logger.trace(`deriving tip planchet: ${j2s(deriveReq)}`);
2021-01-06 17:06:19 +01:00
const p = await ws.cryptoApi.createTipPlanchet(deriveReq);
logger.trace(`derive result: ${j2s(p)}`);
denomForPlanchet[planchets.length] = denom;
planchets.push(p);
planchetsDetail.push({
coin_ev: p.coinEv,
denom_pub_hash: denom.denomPubHash,
});
}
}
2020-09-08 14:10:47 +02:00
const tipStatusUrl = new URL(
2020-11-16 14:12:37 +01:00
`tips/${tipRecord.merchantTipId}/pickup`,
2020-09-08 14:10:47 +02:00
tipRecord.merchantBaseUrl,
);
2020-09-08 14:10:47 +02:00
const req = { planchets: planchetsDetail };
2021-01-06 17:06:19 +01:00
logger.trace(`sending tip request: ${j2s(req)}`);
2020-09-08 14:10:47 +02:00
const merchantResp = await ws.http.postJson(tipStatusUrl.href, req);
2021-01-06 17:06:19 +01:00
logger.trace(`got tip response, status ${merchantResp.status}`);
2022-09-05 18:12:30 +02:00
// FIXME: Why do we do this?
if (
2022-09-05 18:12:30 +02:00
(merchantResp.status >= 500 && merchantResp.status <= 599) ||
merchantResp.status === 424
) {
2021-01-06 17:06:19 +01:00
logger.trace(`got transient tip error`);
// FIXME: wrap in another error code that indicates a transient error
2022-09-05 18:12:30 +02:00
return {
type: OperationAttemptResultType.Error,
errorDetail: makeErrorDetail(
TalerErrorCode.WALLET_UNEXPECTED_REQUEST_ERROR,
getHttpResponseErrorDetails(merchantResp),
"tip pickup failed (transient)",
),
};
}
let blindedSigs: BlindedDenominationSignature[] = [];
const response = await readSuccessResponseJsonOrThrow(
merchantResp,
codecForMerchantTipResponseV2(),
);
blindedSigs = response.blind_sigs.map((x) => x.blind_sig);
if (blindedSigs.length !== planchets.length) {
throw Error("number of tip responses does not match requested planchets");
}
2020-09-08 15:57:08 +02:00
const newCoinRecords: CoinRecord[] = [];
for (let i = 0; i < blindedSigs.length; i++) {
const blindedSig = blindedSigs[i];
2020-09-08 15:57:08 +02:00
const denom = denomForPlanchet[i];
checkLogicInvariant(!!denom);
const planchet = planchets[i];
checkLogicInvariant(!!planchet);
2020-09-08 15:57:08 +02:00
if (denom.denomPub.cipher !== DenomKeyType.Rsa) {
throw Error("unsupported cipher");
}
if (blindedSig.cipher !== DenomKeyType.Rsa) {
2021-11-17 10:23:22 +01:00
throw Error("unsupported cipher");
}
2022-03-23 21:24:23 +01:00
const denomSigRsa = await ws.cryptoApi.rsaUnblind({
bk: planchet.blindingKey,
blindedSig: blindedSig.blinded_rsa_signature,
pk: denom.denomPub.rsa_public_key,
});
2020-09-08 15:57:08 +02:00
2022-03-23 21:24:23 +01:00
const isValid = await ws.cryptoApi.rsaVerify({
hm: planchet.coinPub,
pk: denom.denomPub.rsa_public_key,
sig: denomSigRsa.sig,
});
2020-09-08 15:57:08 +02:00
if (!isValid) {
2022-09-05 18:12:30 +02:00
return {
type: OperationAttemptResultType.Error,
errorDetail: makeErrorDetail(
TalerErrorCode.WALLET_TIPPING_COIN_SIGNATURE_INVALID,
{},
"invalid signature from the exchange (via merchant tip) after unblinding",
),
};
2020-09-08 15:57:08 +02:00
}
newCoinRecords.push({
blindingKey: planchet.blindingKey,
coinPriv: planchet.coinPriv,
coinPub: planchet.coinPub,
coinSource: {
type: CoinSourceType.Tip,
coinIndex: i,
walletTipId: walletTipId,
},
currentAmount: denom.value,
denomPubHash: denom.denomPubHash,
2022-03-23 21:24:23 +01:00
denomSig: { cipher: DenomKeyType.Rsa, rsa_signature: denomSigRsa.sig },
exchangeBaseUrl: tipRecord.exchangeBaseUrl,
2020-09-08 15:57:08 +02:00
status: CoinStatus.Fresh,
suspended: false,
coinEvHash: planchet.coinEvHash,
2020-09-08 15:57:08 +02:00
});
}
2021-06-09 15:14:17 +02:00
await ws.db
.mktx((x) => ({
coins: x.coins,
tips: x.tips,
withdrawalGroups: x.withdrawalGroups,
}))
.runReadWrite(async (tx) => {
const tr = await tx.tips.get(walletTipId);
2019-12-16 16:59:09 +01:00
if (!tr) {
return;
}
if (tr.pickedUpTimestamp) {
2019-12-16 16:59:09 +01:00
return;
}
2022-03-18 15:32:41 +01:00
tr.pickedUpTimestamp = TalerProtocolTimestamp.now();
2021-06-09 15:14:17 +02:00
await tx.tips.put(tr);
2020-09-08 15:57:08 +02:00
for (const cr of newCoinRecords) {
2021-06-09 15:14:17 +02:00
await tx.coins.put(cr);
}
2021-06-09 15:14:17 +02:00
});
2022-09-05 18:12:30 +02:00
return {
type: OperationAttemptResultType.Finished,
result: undefined,
};
}
export async function acceptTip(
ws: InternalWalletState,
tipId: string,
): Promise<void> {
2021-06-09 15:14:17 +02:00
const found = await ws.db
.mktx((x) => ({
tips: x.tips,
}))
.runReadWrite(async (tx) => {
const tipRecord = await tx.tips.get(tipId);
if (!tipRecord) {
logger.error("tip not found");
return false;
}
2022-03-18 15:32:41 +01:00
tipRecord.acceptedTimestamp = TalerProtocolTimestamp.now();
2021-06-09 15:14:17 +02:00
await tx.tips.put(tipRecord);
return true;
});
if (found) {
await processTip(ws, tipId);
}
}