taler/wallet-core
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

the giant refactoring: split wallet into multiple parts

Browse Source
This commit is contained in:
Florian Dold 2019-12-02 00:42:40 +01:00
parent aaf7e1338d
commit e1369ff7e8
No known key found for this signature in database
GPG Key ID: D2E4F00F29D02A4B
60 changed files with 4869 additions and 4139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
package.json
View File

@ -27,6 +27,7 @@
"devDependencies": {
"@types/react": "^16.4.0",
"@types/react-dom": "^16.0.0",
"@types/chrome": "^0.0.91",
"ava": "^2.4.0",
"awesome-typescript-loader": "^5.2.1",
"glob": "^7.1.1",
@ -60,13 +61,10 @@
"webpack-merge": "^4.2.2"
},
"dependencies": {
"@types/chrome": "^0.0.91",
"@types/urijs": "^1.19.3",
"axios": "^0.19.0",
"big-integer": "^1.6.48",
"idb-bridge": "^0.0.15",
"qrcode-generator": "^1.4.3",
"source-map-support": "^0.5.12",
"urijs": "^1.18.10"
"source-map-support": "^0.5.12"
}
}

6
src/android/index.ts
View File

@ -24,10 +24,10 @@ import {
DefaultNodeWalletArgs,
NodeHttpLib,
} from "../headless/helpers";
import { openPromise, OpenedPromise } from "../promiseUtils";
import { openPromise, OpenedPromise } from "../util/promiseUtils";
import fs = require("fs");
import axios from "axios";
import { HttpRequestLibrary, HttpResponse } from "../http";
import { HttpRequestLibrary, HttpResponse } from "../util/http";
import querystring = require("querystring");
// @ts-ignore: special built-in module
@ -66,7 +66,7 @@ export class AndroidHttpLib implements HttpRequestLibrary {
}
}
postJson(url: string, body: any): Promise<import("../http").HttpResponse> {
postJson(url: string, body: any): Promise<import("../util/http").HttpResponse> {
if (this.useNfcTunnel) {
const myId = this.requestId++;
const p = openPromise<HttpResponse>();

12
src/crypto/cryptoApi.ts
View File

@ -22,12 +22,11 @@
/**
* Imports.
*/
import { AmountJson } from "../amounts";
import { AmountJson } from "../util/amounts";
import {
CoinRecord,
DenominationRecord,
PlanchetRecord,
RefreshSessionRecord,
ReserveRecord,
TipPlanchet,
@ -38,9 +37,9 @@ import { CryptoWorker } from "./cryptoWorker";
import { ContractTerms, PaybackRequest } from "../talerTypes";
import { BenchmarkResult, CoinWithDenom, PayCoinInfo, PlanchetCreationResult } from "../walletTypes";
import { BenchmarkResult, CoinWithDenom, PayCoinInfo, PlanchetCreationResult, PlanchetCreationRequest } from "../walletTypes";
import * as timer from "../timer";
import * as timer from "../util/timer";
/**
* State of a crypto worker.
@ -336,10 +335,9 @@ export class CryptoApi {
}
createPlanchet(
denom: DenominationRecord,
reserve: ReserveRecord,
req: PlanchetCreationRequest
): Promise<PlanchetCreationResult> {
return this.doRpc<PlanchetCreationResult>("createPlanchet", 1, denom, reserve);
return this.doRpc<PlanchetCreationResult>("createPlanchet", 1, req);
}
createTipPlanchet(denom: DenominationRecord): Promise<TipPlanchet> {

25
src/crypto/cryptoImplementation.ts
View File

@ -42,11 +42,12 @@ import {
PayCoinInfo,
Timestamp,
PlanchetCreationResult,
PlanchetCreationRequest,
} from "../walletTypes";
import { canonicalJson, getTalerStampSec } from "../helpers";
import { AmountJson } from "../amounts";
import * as Amounts from "../amounts";
import * as timer from "../timer";
import { canonicalJson, getTalerStampSec } from "../util/helpers";
import { AmountJson } from "../util/amounts";
import * as Amounts from "../util/amounts";
import * as timer from "../util/timer";
import {
getRandomBytes,
encodeCrock,
@ -155,24 +156,23 @@ export class CryptoImplementation {
* reserve.
*/
createPlanchet(
denom: DenominationRecord,
reserve: ReserveRecord,
req: PlanchetCreationRequest,
): PlanchetCreationResult {
const reservePub = decodeCrock(reserve.reservePub);
const reservePriv = decodeCrock(reserve.reservePriv);
const denomPub = decodeCrock(denom.denomPub);
const reservePub = decodeCrock(req.reservePub);
const reservePriv = decodeCrock(req.reservePriv);
const denomPub = decodeCrock(req.denomPub);
const coinKeyPair = createEddsaKeyPair();
const blindingFactor = createBlindingKeySecret();
const coinPubHash = hash(coinKeyPair.eddsaPub);
const ev = rsaBlind(coinPubHash, blindingFactor, denomPub);
const amountWithFee = Amounts.add(denom.value, denom.feeWithdraw).amount;
const amountWithFee = Amounts.add(req.value, req.feeWithdraw).amount;
const denomPubHash = hash(denomPub);
const evHash = hash(ev);
const withdrawRequest = buildSigPS(SignaturePurpose.RESERVE_WITHDRAW)
.put(reservePub)
.put(amountToBuffer(amountWithFee))
.put(amountToBuffer(denom.feeWithdraw))
.put(amountToBuffer(req.feeWithdraw))
.put(denomPubHash)
.put(evHash)
.build();
@ -184,10 +184,9 @@ export class CryptoImplementation {
coinEv: encodeCrock(ev),
coinPriv: encodeCrock(coinKeyPair.eddsaPriv),
coinPub: encodeCrock(coinKeyPair.eddsaPub),
coinValue: denom.value,
coinValue: req.value,
denomPub: encodeCrock(denomPub),
denomPubHash: encodeCrock(denomPubHash),
exchangeBaseUrl: reserve.exchangeBaseUrl,
reservePub: encodeCrock(reservePub),
withdrawSig: encodeCrock(sig),
};

10
src/db.ts
View File

@ -1,5 +1,5 @@
import { Stores, WALLET_DB_VERSION } from "./dbTypes";
import { Store, Index } from "./query";
import { Store, Index } from "./util/query";
const DB_NAME = "taler";
@ -21,9 +21,7 @@ export function openTalerDb(
req.onsuccess = e => {
req.result.onversionchange = (evt: IDBVersionChangeEvent) => {
console.log(
`handling live db version change from ${evt.oldVersion} to ${
evt.newVersion
}`,
`handling live db version change from ${evt.oldVersion} to ${evt.newVersion}`,
);
req.result.close();
onVersionChange();
@ -33,9 +31,7 @@ export function openTalerDb(
req.onupgradeneeded = e => {
const db = req.result;
console.log(
`DB: upgrade needed: oldVersion=${e.oldVersion}, newVersion=${
e.newVersion
}`,
`DB: upgrade needed: oldVersion=${e.oldVersion}, newVersion=${e.newVersion}`,
);
switch (e.oldVersion) {
case 0: // DB does not exist yet

116
src/dbTypes.ts
View File

@ -23,8 +23,8 @@
/**
* Imports.
*/
import { AmountJson } from "./amounts";
import { Checkable } from "./checkable";
import { AmountJson } from "./util/amounts";
import { Checkable } from "./util/checkable";
import {
Auditor,
CoinPaySig,
@ -35,7 +35,7 @@ import {
TipResponse,
} from "./talerTypes";
import { Index, Store } from "./query";
import { Index, Store } from "./util/query";
import { Timestamp, OperationError } from "./walletTypes";
/**
@ -444,30 +444,22 @@ export interface ExchangeRecord {
* A coin that isn't yet signed by an exchange.
*/
export interface PlanchetRecord {
withdrawSessionId: string;
/**
* Index of the coin in the withdrawal session.
*/
coinIndex: number;
/**
* Public key of the coin.
*/
coinPub: string;
coinPriv: string;
/**
* Public key of the reserve, this might be a reserve not
* known to the wallet if the planchet is from a tip.
*/
reservePub: string;
denomPubHash: string;
denomPub: string;
blindingKey: string;
withdrawSig: string;
coinEv: string;
exchangeBaseUrl: string;
coinValue: AmountJson;
/**
* Set to true if this pre-coin came from a tip.
* Until the tip is marked as "accepted", the resulting
* coin will not be used for payments.
*/
isFromTip: boolean;
}
@ -511,6 +503,12 @@ export enum CoinStatus {
Dormant = "dormant",
}
export enum CoinSource {
Withdraw = "withdraw",
Refresh = "refresh",
Tip = "tip",
}
/**
* CoinRecord as stored in the "coins" data store
* of the wallet database.
@ -690,11 +688,9 @@ export interface TipRecord {
exchangeUrl: string;
/**
* Domain of the merchant, necessary to uniquely identify the tip since
* merchants can freely choose the ID and a malicious merchant might cause a
* collision.
* Base URL of the merchant that is giving us the tip.
*/
merchantDomain: string;
merchantBaseUrl: string;
/**
* Planchets, the members included in TipPlanchetDetail will be sent to the
@ -702,13 +698,6 @@ export interface TipRecord {
*/
planchets?: TipPlanchet[];
/**
* Coin public keys from the planchets.
* This field is redundant and used for indexing the record via
* a multi-entry index to look up tip records by coin public key.
*/
coinPubs: string[];
/**
* Response if the merchant responded,
* undefined otherwise.
@ -716,18 +705,21 @@ export interface TipRecord {
response?: TipResponse[];
/**
* Identifier for the tip, chosen by the merchant.
* Tip ID chosen by the wallet.
*/
tipId: string;
/**
* The merchant's identifier for this tip.
*/
merchantTipId: string;
/**
* URL to go to once the tip has been accepted.
*/
nextUrl?: string;
timestamp: Timestamp;
pickupUrl: string;
}
/**
@ -983,13 +975,24 @@ export interface CoinsReturnRecord {
wire: any;
}
export interface WithdrawalSourceTip {
type: "tip";
tipId: string;
}
export interface WithdrawalSourceReserve {
type: "reserve";
reservePub: string;
}
export type WithdrawalSource = WithdrawalSourceTip | WithdrawalSourceReserve
export interface WithdrawalSessionRecord {
withdrawSessionId: string;
/**
* Reserve that we're withdrawing from.
*/
reservePub: string;
source: WithdrawalSource;
exchangeBaseUrl: string;
/**
* When was the withdrawal operation started started?
@ -1010,15 +1013,12 @@ export interface WithdrawalSessionRecord {
denoms: string[];
planchets: (undefined | PlanchetRecord)[];
/**
* Coins in this session that are withdrawn are set to true.
*/
withdrawn: boolean[];
/**
* Coins in this session already have a planchet are set to true.
*/
planchetCreated: boolean[];
}
export interface BankWithdrawUriRecord {
@ -1071,11 +1071,7 @@ export namespace Stores {
constructor() {
super("proposals", { keyPath: "proposalId" });
}
urlIndex = new Index<string, ProposalRecord>(
this,
"urlIndex",
"url",
);
urlIndex = new Index<string, ProposalRecord>(this, "urlIndex", "url");
}
class PurchasesStore extends Store<PurchaseRecord> {
@ -1140,16 +1136,8 @@ export namespace Stores {
class TipsStore extends Store<TipRecord> {
constructor() {
super("tips", {
keyPath: (["tipId", "merchantDomain"] as any) as IDBKeyPath,
});
super("tips", { keyPath: "tipId" });
}
coinPubIndex = new Index<string, TipRecord>(
this,
"coinPubIndex",
"coinPubs",
{ multiEntry: true },
);
}
class SenderWiresStore extends Store<SenderWireRecord> {
@ -1162,11 +1150,6 @@ export namespace Stores {
constructor() {
super("withdrawals", { keyPath: "withdrawSessionId" });
}
byReservePub = new Index<string, WithdrawalSessionRecord>(
this,
"withdrawalsReservePubIndex",
"reservePub",
);
}
class BankWithdrawUrisStore extends Store<BankWithdrawUriRecord> {
@ -1175,24 +1158,6 @@ export namespace Stores {
}
}
class PlanchetsStore extends Store<PlanchetRecord> {
constructor() {
super("planchets", {
keyPath: "coinPub",
});
}
byReservePub = new Index<string, PlanchetRecord>(
this,
"planchetsReservePubIndex",
"reservePub",
);
byWithdrawalWithIdx = new Index<any, PlanchetRecord>(
this,
"planchetsByWithdrawalWithIdxIndex",
["withdrawSessionId", "coinIndex"],
);
}
export const coins = new CoinsStore();
export const coinsReturns = new Store<CoinsReturnRecord>("coinsReturns", {
keyPath: "contractTermsHash",
@ -1201,7 +1166,6 @@ export namespace Stores {
export const currencies = new CurrenciesStore();
export const denominations = new DenominationsStore();
export const exchanges = new ExchangesStore();
export const planchets = new PlanchetsStore();
export const proposals = new ProposalsStore();
export const refresh = new Store<RefreshSessionRecord>("refresh", {
keyPath: "refreshSessionId",

11
src/headless/bank.ts
View File

@ -25,7 +25,6 @@
*/
import Axios from "axios";
import querystring = require("querystring");
import URI = require("urijs");
export interface BankUser {
username: string;
@ -50,9 +49,7 @@ export class Bank {
amount,
};
const reqUrl = new URI("api/withdraw-headless-uri")
.absoluteTo(this.bankBaseUrl)
.href();
const reqUrl = new URL("api/withdraw-headless-uri", this.bankBaseUrl).href;
const resp = await Axios({
method: "post",
@ -82,9 +79,7 @@ export class Bank {
reservePub: string,
exchangePaytoUri: string,
) {
const reqUrl = new URI("api/withdraw-headless")
.absoluteTo(this.bankBaseUrl)
.href();
const reqUrl = new URL("api/withdraw-headless", this.bankBaseUrl).href;
const body = {
auth: { type: "basic" },
@ -111,7 +106,7 @@ export class Bank {
}
async registerRandomUser(): Promise<BankUser> {
const reqUrl = new URI("api/register").absoluteTo(this.bankBaseUrl).href();
const reqUrl = new URL("api/register", this.bankBaseUrl).href;
const randId = makeId(8);
const bankUser: BankUser = {
username: `testuser-${randId}`,

10
src/headless/helpers.ts
View File

@ -28,13 +28,13 @@ import { SynchronousCryptoWorkerFactory } from "../crypto/synchronousWorker";
import { openTalerDb } from "../db";
import Axios from "axios";
import querystring = require("querystring");
import { HttpRequestLibrary } from "../http";
import * as amounts from "../amounts";
import { HttpRequestLibrary } from "../util/http";
import * as amounts from "../util/amounts";
import { Bank } from "./bank";
import fs = require("fs");
import { NodeCryptoWorkerFactory } from "../crypto/nodeProcessWorker";
import { Logger } from "../logging";
import { Logger } from "../util/logging";
const logger = new Logger("helpers.ts");
@ -51,7 +51,7 @@ class ConsoleBadge implements Badge {
}
export class NodeHttpLib implements HttpRequestLibrary {
async get(url: string): Promise<import("../http").HttpResponse> {
async get(url: string): Promise<import("../util/http").HttpResponse> {
try {
const resp = await Axios({
method: "get",
@ -70,7 +70,7 @@ export class NodeHttpLib implements HttpRequestLibrary {
async postJson(
url: string,
body: any,
): Promise<import("../http").HttpResponse> {
): Promise<import("../util/http").HttpResponse> {
try {
const resp = await Axios({
method: "post",

13
src/headless/merchant.ts
View File

@ -24,7 +24,6 @@
*/
import axios from "axios";
import { CheckPaymentResponse } from "../talerTypes";
import URI = require("urijs");
/**
* Connection to the *internal* merchant backend.
@ -35,7 +34,7 @@ export class MerchantBackendConnection {
reason: string,
refundAmount: string,
): Promise<void> {
const reqUrl = new URI("refund").absoluteTo(this.merchantBaseUrl).href();
const reqUrl = new URL("refund", this.merchantBaseUrl);
const refundReq = {
order_id: orderId,
reason,
@ -43,7 +42,7 @@ export class MerchantBackendConnection {
};
const resp = await axios({
method: "post",
url: reqUrl,
url: reqUrl.href,
data: refundReq,
responseType: "json",
headers: {
@ -64,7 +63,7 @@ export class MerchantBackendConnection {
constructor(public merchantBaseUrl: string, public apiKey: string) {}
async authorizeTip(amount: string, justification: string) {
const reqUrl = new URI("tip-authorize").absoluteTo(this.merchantBaseUrl).href();
const reqUrl = new URL("tip-authorize", this.merchantBaseUrl).href;
const tipReq = {
amount,
justification,
@ -90,7 +89,7 @@ export class MerchantBackendConnection {
summary: string,
fulfillmentUrl: string,
): Promise<{ orderId: string }> {
const reqUrl = new URI("order").absoluteTo(this.merchantBaseUrl).href();
const reqUrl = new URL("order", this.merchantBaseUrl).href;
const orderReq = {
order: {
amount,
@ -118,9 +117,7 @@ export class MerchantBackendConnection {
}
async checkPayment(orderId: string): Promise<CheckPaymentResponse> {
const reqUrl = new URI("check-payment")
.absoluteTo(this.merchantBaseUrl)
.href();
const reqUrl = new URL("check-payment", this.merchantBaseUrl).href;
const resp = await axios({
method: "get",
url: reqUrl,

7
src/headless/taler-wallet-cli.ts
View File

@ -23,8 +23,8 @@ import { Wallet, OperationFailedAndReportedError } from "../wallet";
import qrcodeGenerator = require("qrcode-generator");
import * as clk from "./clk";
import { BridgeIDBFactory, MemoryBackend } from "idb-bridge";
import { Logger } from "../logging";
import * as Amounts from "../amounts";
import { Logger } from "../util/logging";
import * as Amounts from "../util/amounts";
import { decodeCrock } from "../crypto/talerCrypto";
import { Bank } from "./bank";
@ -93,7 +93,6 @@ async function doPay(
function applyVerbose(verbose: boolean) {
if (verbose) {
console.log("enabled verbose logging");
Wallet.enableTracing = true;
BridgeIDBFactory.enableTracing = true;
}
}
@ -217,7 +216,7 @@ walletCli
} else if (uri.startsWith("taler://tip/")) {
const res = await wallet.getTipStatus(uri);
console.log("tip status", res);
await wallet.acceptTip(uri);
await wallet.acceptTip(res.tipId);
} else if (uri.startsWith("taler://refund/")) {
await wallet.applyRefund(uri);
} else if (uri.startsWith("taler://withdraw/")) {

6
src/talerTypes.ts
View File

@ -26,11 +26,11 @@
/**
* Imports.
*/
import { Checkable } from "./checkable";
import { Checkable } from "./util/checkable";
import * as Amounts from "./amounts";
import * as Amounts from "./util/amounts";
import { timestampCheck } from "./helpers";
import { timestampCheck } from "./util/helpers";
/**
* Denomination as found in the /keys response from the exchange.

76
src/types-test.ts
View File

@ -15,12 +15,16 @@
*/
import test from "ava";
import * as Amounts from "./amounts";
import * as Amounts from "./util/amounts";
import { ContractTerms } from "./talerTypes";
const amt = (value: number, fraction: number, currency: string): Amounts.AmountJson => ({value, fraction, currency});
const amt = (
value: number,
fraction: number,
currency: string,
): Amounts.AmountJson => ({ value, fraction, currency });
test("amount addition (simple)", (t) => {
test("amount addition (simple)", t => {
const a1 = amt(1, 0, "EUR");
const a2 = amt(1, 0, "EUR");
const a3 = amt(2, 0, "EUR");
@ -28,14 +32,14 @@ test("amount addition (simple)", (t) => {
t.pass();
});
test("amount addition (saturation)", (t) => {
test("amount addition (saturation)", t => {
const a1 = amt(1, 0, "EUR");
const res = Amounts.add(amt(Amounts.maxAmountValue, 0, "EUR"), a1);
t.true(res.saturated);
t.pass();
});
test("amount subtraction (simple)", (t) => {
test("amount subtraction (simple)", t => {
const a1 = amt(2, 5, "EUR");
const a2 = amt(1, 0, "EUR");
const a3 = amt(1, 5, "EUR");
@ -43,7 +47,7 @@ test("amount subtraction (simple)", (t) => {
t.pass();
});
test("amount subtraction (saturation)", (t) => {
test("amount subtraction (saturation)", t => {
const a1 = amt(0, 0, "EUR");
const a2 = amt(1, 0, "EUR");
let res = Amounts.sub(a1, a2);
@ -53,8 +57,7 @@ test("amount subtraction (saturation)", (t) => {
t.pass();
});
test("amount comparison", (t) => {
test("amount comparison", t => {
t.is(Amounts.cmp(amt(1, 0, "EUR"), amt(1, 0, "EUR")), 0);
t.is(Amounts.cmp(amt(1, 1, "EUR"), amt(1, 0, "EUR")), 1);
t.is(Amounts.cmp(amt(1, 1, "EUR"), amt(1, 2, "EUR")), -1);
@ -65,18 +68,36 @@ test("amount comparison", (t) => {
t.pass();
});
test("amount parsing", (t) => {
t.is(Amounts.cmp(Amounts.parseOrThrow("TESTKUDOS:0"),
amt(0, 0, "TESTKUDOS")), 0);
t.is(Amounts.cmp(Amounts.parseOrThrow("TESTKUDOS:10"),
amt(10, 0, "TESTKUDOS")), 0);
t.is(Amounts.cmp(Amounts.parseOrThrow("TESTKUDOS:0.1"),
amt(0, 10000000, "TESTKUDOS")), 0);
t.is(Amounts.cmp(Amounts.parseOrThrow("TESTKUDOS:0.00000001"),
amt(0, 1, "TESTKUDOS")), 0);
t.is(Amounts.cmp(Amounts.parseOrThrow("TESTKUDOS:4503599627370496.99999999"),
amt(4503599627370496, 99999999, "TESTKUDOS")), 0);
test("amount parsing", t => {
t.is(
Amounts.cmp(Amounts.parseOrThrow("TESTKUDOS:0"), amt(0, 0, "TESTKUDOS")),
0,
);
t.is(
Amounts.cmp(Amounts.parseOrThrow("TESTKUDOS:10"), amt(10, 0, "TESTKUDOS")),
0,
);
t.is(
Amounts.cmp(
Amounts.parseOrThrow("TESTKUDOS:0.1"),
amt(0, 10000000, "TESTKUDOS"),
),
0,
);
t.is(
Amounts.cmp(
Amounts.parseOrThrow("TESTKUDOS:0.00000001"),
amt(0, 1, "TESTKUDOS"),
),
0,
);
t.is(
Amounts.cmp(
Amounts.parseOrThrow("TESTKUDOS:4503599627370496.99999999"),
amt(4503599627370496, 99999999, "TESTKUDOS"),
),
0,
);
t.throws(() => Amounts.parseOrThrow("foo:"));
t.throws(() => Amounts.parseOrThrow("1.0"));
t.throws(() => Amounts.parseOrThrow("42"));
@ -85,14 +106,18 @@ test("amount parsing", (t) => {
t.throws(() => Amounts.parseOrThrow("EUR:.42"));
t.throws(() => Amounts.parseOrThrow("EUR:42."));
t.throws(() => Amounts.parseOrThrow("TESTKUDOS:4503599627370497.99999999"));
t.is(Amounts.cmp(Amounts.parseOrThrow("TESTKUDOS:0.99999999"),
amt(0, 99999999, "TESTKUDOS")), 0);
t.is(
Amounts.cmp(
Amounts.parseOrThrow("TESTKUDOS:0.99999999"),
amt(0, 99999999, "TESTKUDOS"),
),
0,
);
t.throws(() => Amounts.parseOrThrow("TESTKUDOS:0.999999991"));
t.pass();
});
test("amount stringification", (t) => {
test("amount stringification", t => {
t.is(Amounts.toString(amt(0, 0, "TESTKUDOS")), "TESTKUDOS:0");
t.is(Amounts.toString(amt(4, 94000000, "TESTKUDOS")), "TESTKUDOS:4.94");
t.is(Amounts.toString(amt(0, 10000000, "TESTKUDOS")), "TESTKUDOS:0.1");
@ -103,8 +128,7 @@ test("amount stringification", (t) => {
t.pass();
});
test("contract terms validation", (t) => {
test("contract terms validation", t => {
const c = {
H_wire: "123",
amount: "EUR:1.5",

0
src/amounts.ts → src/util/amounts.ts
View File

19
src/util/assertUnreachable.ts Normal file
View File

@ -0,0 +1,19 @@
/*
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/>
*/
export function assertUnreachable(x: never): never {
throw new Error("Didn't expect to get here");
}

52
src/util/asyncMemo.ts Normal file
View File

@ -0,0 +1,52 @@
/*
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/>
*/
export interface MemoEntry<T> {
p: Promise<T>;
t: number;
n: number;
}
export class AsyncOpMemo<T> {
n = 0;
memo: { [k: string]: MemoEntry<T> } = {};
put(key: string, p: Promise<T>): Promise<T> {
const n = this.n++;
this.memo[key] = {
p,
n,
t: new Date().getTime(),
};
p.finally(() => {
const r = this.memo[key];
if (r && r.n === n) {
delete this.memo[key];
}
});
return p;
}
find(key: string): Promise<T> | undefined {
const res = this.memo[key];
const tNow = new Date().getTime();
if (res && res.t < tNow - 10 * 1000) {
delete this.memo[key];
return;
} else if (res) {
return res.p;
}
return;
}
}

0
src/checkable.ts → src/util/checkable.ts
View File

0
src/helpers-test.ts → src/util/helpers-test.ts
View File

15
src/helpers.ts → src/util/helpers.ts
View File

@ -24,8 +24,7 @@
import { AmountJson } from "./amounts";
import * as Amounts from "./amounts";
import URI = require("urijs");
import { Timestamp } from "./walletTypes";
import { Timestamp } from "../walletTypes";
/**
* Show an amount in a form suitable for the user.
@ -47,11 +46,13 @@ export function canonicalizeBaseUrl(url: string) {
if (!url.startsWith("http") && !url.startsWith("https")) {
url = "https://" + url;
}
const x = new URI(url);
x.path(x.path() + "/").normalizePath();
x.fragment("");
x.query();
return x.href();
const x = new URL(url);
if (!x.pathname.endsWith("/")) {
x.pathname = x.pathname + "/";
}
x.search = "";
x.hash = "";
return x.href;
}

0
src/http.ts → src/util/http.ts
View File

0
src/libtoolVersion-test.ts → src/util/libtoolVersion-test.ts
View File

0
src/libtoolVersion.ts → src/util/libtoolVersion.ts
View File

2
src/logging.ts → src/util/logging.ts
View File

@ -19,7 +19,7 @@ export class Logger {
info(message: string, ...args: any[]) {
console.log(`${new Date().toISOString()} ${this.tag} INFO ` + message, ...args);
}
trace(message: string, ...args: any[]) {
trace(message: any, ...args: any[]) {
console.log(`${new Date().toISOString()} ${this.tag} TRACE ` + message, ...args)
}
}

31
src/util/payto-test.ts Normal file
View File

@ -0,0 +1,31 @@
/*
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/>
*/
import test from "ava";
import { parsePaytoUri } from "./payto";
test("basic payto parsing", (t) => {
const r1 = parsePaytoUri("https://example.com/");
t.is(r1, undefined);
const r2 = parsePaytoUri("payto:blabla");
t.is(r2, undefined);
const r3 = parsePaytoUri("payto://x-taler-bank/123");
t.is(r3?.targetType, "x-taler-bank");
t.is(r3?.targetPath, "123");
});

54
src/util/payto.ts Normal file
View File

@ -0,0 +1,54 @@
/*
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/>
*/
interface PaytoUri {
targetType: string;
targetPath: string;
params: { [name: string]: string };
}
export function parsePaytoUri(s: string): PaytoUri | undefined {
const pfx = "payto://"
if (!s.startsWith(pfx)) {
return undefined;
}
const [acct, search] = s.slice(pfx.length).split("?");
const firstSlashPos = acct.indexOf("/");
if (firstSlashPos === -1) {
return undefined;
}
const targetType = acct.slice(0, firstSlashPos);
const targetPath = acct.slice(firstSlashPos + 1);
const params: { [k: string]: string } = {};
const searchParams = new URLSearchParams(search || "");
searchParams.forEach((v, k) => {
params[v] = k;
});
return {
targetPath,
targetType,
params,
}
}

0
src/promiseUtils.ts → src/util/promiseUtils.ts
View File

0
src/query.ts → src/util/query.ts
View File

98
src/taleruri-test.ts → src/util/taleruri-test.ts
View File

@ -1,5 +1,5 @@
/*
This file is part of TALER
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
@ -15,9 +15,14 @@
*/
import test from "ava";
import { parsePayUri, parseWithdrawUri, parseRefundUri, parseTipUri } from "./taleruri";
import {
parsePayUri,
parseWithdrawUri,
parseRefundUri,
parseTipUri,
} from "./taleruri";
test("taler pay url parsing: http(s)", (t) => {
test("taler pay url parsing: http(s)", t => {
const url1 = "https://example.com/bar?spam=eggs";
const r1 = parsePayUri(url1);
if (!r1) {
@ -34,8 +39,7 @@ test("taler pay url parsing: http(s)", (t) => {
}
});
test("taler pay url parsing: wrong scheme", (t) => {
test("taler pay url parsing: wrong scheme", t => {
const url1 = "talerfoo://";
const r1 = parsePayUri(url1);
t.is(r1, undefined);
@ -45,8 +49,7 @@ test("taler pay url parsing: wrong scheme", (t) => {
t.is(r2, undefined);
});
test("taler pay url parsing: defaults", (t) => {
test("taler pay url parsing: defaults", t => {
const url1 = "taler://pay/example.com/-/-/myorder";
const r1 = parsePayUri(url1);
if (!r1) {
@ -66,8 +69,7 @@ test("taler pay url parsing: defaults", (t) => {
t.is(r2.sessionId, "mysession");
});
test("taler pay url parsing: trailing parts", (t) => {
test("taler pay url parsing: trailing parts", t => {
const url1 = "taler://pay/example.com/-/-/myorder/mysession/spam/eggs";
const r1 = parsePayUri(url1);
if (!r1) {
@ -78,49 +80,59 @@ test("taler pay url parsing: trailing parts", (t) => {
t.is(r1.sessionId, "mysession");
});
test("taler pay url parsing: instance", (t) => {
test("taler pay url parsing: instance", t => {
const url1 = "taler://pay/example.com/-/myinst/myorder";
const r1 = parsePayUri(url1);
if (!r1) {
t.fail();
return;
}
t.is(r1.downloadUrl, "https://example.com/public/instances/myinst/proposal?order_id=myorder");
t.is(
r1.downloadUrl,
"https://example.com/public/instances/myinst/proposal?order_id=myorder",
);
});
test("taler pay url parsing: path prefix and instance", (t) => {
test("taler pay url parsing: path prefix and instance", t => {
const url1 = "taler://pay/example.com/mypfx/myinst/myorder";
const r1 = parsePayUri(url1);
if (!r1) {
t.fail();
return;
}
t.is(r1.downloadUrl, "https://example.com/mypfx/instances/myinst/proposal?order_id=myorder");
t.is(
r1.downloadUrl,
"https://example.com/mypfx/instances/myinst/proposal?order_id=myorder",
);
});
test("taler pay url parsing: complex path prefix", (t) => {
test("taler pay url parsing: complex path prefix", t => {
const url1 = "taler://pay/example.com/mypfx%2Fpublic/-/myorder";
const r1 = parsePayUri(url1);
if (!r1) {
t.fail();
return;
}
t.is(r1.downloadUrl, "https://example.com/mypfx/public/proposal?order_id=myorder");
t.is(
r1.downloadUrl,
"https://example.com/mypfx/public/proposal?order_id=myorder",
);
});
test("taler pay url parsing: complex path prefix and instance", (t) => {
test("taler pay url parsing: complex path prefix and instance", t => {
const url1 = "taler://pay/example.com/mypfx%2Fpublic/foo/myorder";
const r1 = parsePayUri(url1);
if (!r1) {
t.fail();
return;
}
t.is(r1.downloadUrl, "https://example.com/mypfx/public/instances/foo/proposal?order_id=myorder");
t.is(
r1.downloadUrl,
"https://example.com/mypfx/public/instances/foo/proposal?order_id=myorder",
);
});
test("taler pay url parsing: non-https #1", (t) => {
test("taler pay url parsing: non-https #1", t => {
const url1 = "taler://pay/example.com/-/-/myorder?insecure=1";
const r1 = parsePayUri(url1);
if (!r1) {
@ -130,7 +142,7 @@ test("taler pay url parsing: non-https #1", (t) => {
t.is(r1.downloadUrl, "http://example.com/public/proposal?order_id=myorder");
});
test("taler pay url parsing: non-https #2", (t) => {
test("taler pay url parsing: non-https #2", t => {
const url1 = "taler://pay/example.com/-/-/myorder?insecure=2";
const r1 = parsePayUri(url1);
if (!r1) {
@ -140,8 +152,7 @@ test("taler pay url parsing: non-https #2", (t) => {
t.is(r1.downloadUrl, "https://example.com/public/proposal?order_id=myorder");
});
test("taler withdraw uri parsing", (t) => {
test("taler withdraw uri parsing", t => {
const url1 = "taler://withdraw/bank.example.com/-/12345";
const r1 = parseWithdrawUri(url1);
if (!r1) {
@ -151,56 +162,69 @@ test("taler withdraw uri parsing", (t) => {
t.is(r1.statusUrl, "https://bank.example.com/api/withdraw-operation/12345");
});
test("taler refund uri parsing", (t) => {
test("taler refund uri parsing", t => {
const url1 = "taler://refund/merchant.example.com/-/-/1234";
const r1 = parseRefundUri(url1);
if (!r1) {
t.fail();
return;
}
t.is(r1.refundUrl, "https://merchant.example.com/public/refund?order_id=1234");
t.is(
r1.refundUrl,
"https://merchant.example.com/public/refund?order_id=1234",
);
});
test("taler refund uri parsing with instance", (t) => {
test("taler refund uri parsing with instance", t => {
const url1 = "taler://refund/merchant.example.com/-/myinst/1234";
const r1 = parseRefundUri(url1);
if (!r1) {
t.fail();
return;
}
t.is(r1.refundUrl, "https://merchant.example.com/public/instances/myinst/refund?order_id=1234");
t.is(
r1.refundUrl,
"https://merchant.example.com/public/instances/myinst/refund?order_id=1234",
);
});
test("taler tip pickup uri", (t) => {
test("taler tip pickup uri", t => {
const url1 = "taler://tip/merchant.example.com/-/-/tipid";
const r1 = parseTipUri(url1);
if (!r1) {
t.fail();
return;
}
t.is(r1.tipPickupUrl, "https://merchant.example.com/public/tip-pickup?tip_id=tipid");
t.is(
r1.merchantBaseUrl,
"https://merchant.example.com/public/tip-pickup?tip_id=tipid",
);
});
test("taler tip pickup uri with instance", (t) => {
test("taler tip pickup uri with instance", t => {
const url1 = "taler://tip/merchant.example.com/-/tipm/tipid";
const r1 = parseTipUri(url1);
if (!r1) {
t.fail();
return;
}
t.is(r1.tipPickupUrl, "https://merchant.example.com/public/instances/tipm/tip-pickup?tip_id=tipid");
t.is(
r1.merchantBaseUrl,
"https://merchant.example.com/public/instances/tipm/",
);
t.is(r1.merchantTipId, "tipid");
});
test("taler tip pickup uri with instance and prefix", (t) => {
test("taler tip pickup uri with instance and prefix", t => {
const url1 = "taler://tip/merchant.example.com/my%2fpfx/tipm/tipid";
const r1 = parseTipUri(url1);
if (!r1) {
t.fail();
return;
}
t.is(r1.tipPickupUrl, "https://merchant.example.com/my/pfx/instances/tipm/tip-pickup?tip_id=tipid");
t.is(
r1.merchantBaseUrl,
"https://merchant.example.com/my/pfx/instances/tipm/",
);
t.is(r1.merchantTipId, "tipid");
});

118
src/taleruri.ts → src/util/taleruri.ts
View File

@ -1,5 +1,5 @@
/*
This file is part of TALER
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
@ -14,9 +14,6 @@
GNU Taler; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
*/
import URI = require("urijs");
import { string } from "prop-types";
export interface PayUriResult {
downloadUrl: string;
sessionId?: string;
@ -31,58 +28,47 @@ export interface RefundUriResult {
}
export interface TipUriResult {
tipPickupUrl: string;
tipId: string;
merchantInstance: string;
merchantTipId: string;
merchantOrigin: string;
merchantBaseUrl: string;
}
export function parseWithdrawUri(s: string): WithdrawUriResult | undefined {
const parsedUri = new URI(s);
if (parsedUri.scheme() !== "taler") {
return undefined;
}
if (parsedUri.authority() != "withdraw") {
const pfx = "taler://withdraw/";
if (!s.startsWith(pfx)) {
return undefined;
}
let [host, path, withdrawId] = parsedUri.segmentCoded();
const rest = s.substring(pfx.length);
let [host, path, withdrawId] = rest.split("/");
if (path === "-") {
path = "/api/withdraw-operation";
path = "api/withdraw-operation";
}
return {
statusUrl: new URI({ protocol: "https", hostname: host, path: path })
.segmentCoded(withdrawId)
.href(),
statusUrl: `https://${host}/${path}/${withdrawId}`,
};
}
export function parsePayUri(s: string): PayUriResult | undefined {
const parsedUri = new URI(s);
const query: any = parsedUri.query(true);
if (parsedUri.scheme() === "http" || parsedUri.scheme() === "https") {
if (s.startsWith("https://") || s.startsWith("http://")) {
return {
downloadUrl: s,
sessionId: undefined,
};
}
if (parsedUri.scheme() != "taler") {
return undefined;
}
if (parsedUri.authority() != "pay") {
const pfx = "taler://pay/";
if (!s.startsWith(pfx)) {
return undefined;
}
let [
_,
host,
maybePath,
maybeInstance,
orderId,
maybeSessionid,
] = parsedUri.path().split("/");
const [path, search] = s.slice(pfx.length).split("?");
let [host, maybePath, maybeInstance, orderId, maybeSessionid] = path.split(
"/",
);
if (!host) {
return undefined;
@ -107,15 +93,16 @@ export function parsePayUri(s: string): PayUriResult | undefined {
}
let protocol = "https";
if (query["insecure"] === "1") {
const searchParams = new URLSearchParams(search);
if (searchParams.get("insecure") === "1") {
protocol = "http";
}
const downloadUrl = new URI(
protocol + "://" + host + "/" + decodeURIComponent(maybePath) + maybeInstancePath + "proposal",
)
.addQuery({ order_id: orderId })
.href();
const downloadUrl =
`${protocol}://${host}/` +
decodeURIComponent(maybePath) +
maybeInstancePath +
`proposal?order_id=${orderId}`;
return {
downloadUrl,
@ -124,15 +111,14 @@ export function parsePayUri(s: string): PayUriResult | undefined {
}
export function parseTipUri(s: string): TipUriResult | undefined {
const parsedUri = new URI(s);
if (parsedUri.scheme() != "taler") {
return undefined;
}
if (parsedUri.authority() != "tip") {
const pfx = "taler://tip/";
if (!s.startsWith(pfx)) {
return undefined;
}
let [_, host, maybePath, maybeInstance, tipId] = parsedUri.path().split("/");
const path = s.slice(pfx.length);
let [host, maybePath, maybeInstance, tipId] = path.split("/");
if (!host) {
return undefined;
@ -156,34 +142,25 @@ export function parseTipUri(s: string): TipUriResult | undefined {
maybeInstancePath = `instances/${maybeInstance}/`;
}
const tipPickupUrl = new URI(
"https://" + host + "/" + maybePath + maybeInstancePath + "tip-pickup",
).addQuery({ tip_id: tipId }).href();
const merchantBaseUrl = `https://${host}/${maybePath}${maybeInstancePath}`;
return {
tipPickupUrl,
tipId: tipId,
merchantInstance: maybeInstance,
merchantOrigin: new URI(tipPickupUrl).origin(),
merchantTipId: tipId,
merchantOrigin: new URL(merchantBaseUrl).origin,
merchantBaseUrl,
};
}
export function parseRefundUri(s: string): RefundUriResult | undefined {
const parsedUri = new URI(s);
if (parsedUri.scheme() != "taler") {
return undefined;
}
if (parsedUri.authority() != "refund") {
const pfx = "taler://refund/";
if (!s.startsWith(pfx)) {
return undefined;
}
let [
_,
host,
maybePath,
maybeInstance,
orderId,
] = parsedUri.path().split("/");
const path = s.slice(pfx.length);
let [host, maybePath, maybeInstance, orderId] = path.split("/");
if (!host) {
return undefined;
@ -207,11 +184,16 @@ export function parseRefundUri(s: string): RefundUriResult | undefined {
maybeInstancePath = `instances/${maybeInstance}/`;
}
const refundUrl = new URI(
"https://" + host + "/" + maybePath + maybeInstancePath + "refund",
)
.addQuery({ order_id: orderId })
.href();
const refundUrl =
"https://" +
host +
"/" +
maybePath +
maybeInstancePath +
"refund" +
"?order_id=" +
orderId;
return {
refundUrl,
};

0
src/timer.ts → src/util/timer.ts
View File

2
src/wire.ts → src/util/wire.ts
View File

@ -25,7 +25,7 @@
/**
* Imports.
*/
import * as i18n from "./i18n";
import * as i18n from "../i18n";
/**
* Short summary of the wire information.

144
src/wallet-impl/balance.ts Normal file
View File

@ -0,0 +1,144 @@
/*
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/>
*/
/**
* Imports.
*/
import {
HistoryQuery,
HistoryEvent,
WalletBalance,
WalletBalanceEntry,
} from "../walletTypes";
import { oneShotIter, runWithWriteTransaction } from "../util/query";
import { InternalWalletState } from "./state";
import { Stores, TipRecord, CoinStatus } from "../dbTypes";
import * as Amounts from "../util/amounts";
import { AmountJson } from "../util/amounts";
import { Logger } from "../util/logging";
const logger = new Logger("withdraw.ts");
/**
* Get detailed balance information, sliced by exchange and by currency.
*/
export async function getBalances(
ws: InternalWalletState,
): Promise<WalletBalance> {
/**
* Add amount to a balance field, both for
* the slicing by exchange and currency.
*/
function addTo(
balance: WalletBalance,
field: keyof WalletBalanceEntry,
amount: AmountJson,
exchange: string,
): void {
const z = Amounts.getZero(amount.currency);
const balanceIdentity = {
available: z,
paybackAmount: z,
pendingIncoming: z,
pendingPayment: z,
pendingIncomingDirty: z,
pendingIncomingRefresh: z,
pendingIncomingWithdraw: z,
};
let entryCurr = balance.byCurrency[amount.currency];
if (!entryCurr) {
balance.byCurrency[amount.currency] = entryCurr = {
...balanceIdentity,
};
}
let entryEx = balance.byExchange[exchange];
if (!entryEx) {
balance.byExchange[exchange] = entryEx = { ...balanceIdentity };
}
entryCurr[field] = Amounts.add(entryCurr[field], amount).amount;
entryEx[field] = Amounts.add(entryEx[field], amount).amount;
}
const balanceStore = {
byCurrency: {},
byExchange: {},
};
await runWithWriteTransaction(
ws.db,
[Stores.coins, Stores.refresh, Stores.reserves, Stores.purchases],
async tx => {
await tx.iter(Stores.coins).forEach(c => {
if (c.suspended) {
return;
}
if (c.status === CoinStatus.Fresh) {
addTo(balanceStore, "available", c.currentAmount, c.exchangeBaseUrl);
}
if (c.status === CoinStatus.Dirty) {
addTo(
balanceStore,
"pendingIncoming",
c.currentAmount,
c.exchangeBaseUrl,
);
addTo(
balanceStore,
"pendingIncomingDirty",
c.currentAmount,
c.exchangeBaseUrl,
);
}
});
await tx.iter(Stores.refresh).forEach(r => {
// Don't count finished refreshes, since the refresh already resulted
// in coins being added to the wallet.
if (r.finished) {
return;
}
addTo(
balanceStore,
"pendingIncoming",
r.valueOutput,
r.exchangeBaseUrl,
);
addTo(
balanceStore,
"pendingIncomingRefresh",
r.valueOutput,
r.exchangeBaseUrl,
);
});
await tx.iter(Stores.purchases).forEach(t => {
if (t.finished) {
return;
}
for (const c of t.payReq.coins) {
addTo(
balanceStore,
"pendingPayment",
Amounts.parseOrThrow(c.contribution),
c.exchange_url,
);
}
});
},
);
logger.trace("computed balances:", balanceStore);
return balanceStore;
}

401
src/wallet-impl/exchanges.ts Normal file
View File

@ -0,0 +1,401 @@
/*
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/>
*/
import { InternalWalletState } from "./state";
import {
WALLET_CACHE_BREAKER_CLIENT_VERSION,
OperationFailedAndReportedError,
} from "../wallet";
import { KeysJson, Denomination, ExchangeWireJson } from "../talerTypes";
import { getTimestampNow, OperationError } from "../walletTypes";
import {
ExchangeRecord,
ExchangeUpdateStatus,
Stores,
DenominationRecord,
DenominationStatus,
WireFee,
} from "../dbTypes";
import {
canonicalizeBaseUrl,
extractTalerStamp,
extractTalerStampOrThrow,
} from "../util/helpers";
import {
oneShotGet,
oneShotPut,
runWithWriteTransaction,
oneShotMutate,
} from "../util/query";
import * as Amounts from "../util/amounts";
import { parsePaytoUri } from "../util/payto";
async function denominationRecordFromKeys(
ws: InternalWalletState,
exchangeBaseUrl: string,
denomIn: Denomination,
): Promise<DenominationRecord> {
const denomPubHash = await ws.cryptoApi.hashDenomPub(denomIn.denom_pub);
const d: DenominationRecord = {
denomPub: denomIn.denom_pub,
denomPubHash,
exchangeBaseUrl,
feeDeposit: Amounts.parseOrThrow(denomIn.fee_deposit),
feeRefresh: Amounts.parseOrThrow(denomIn.fee_refresh),
feeRefund: Amounts.parseOrThrow(denomIn.fee_refund),
feeWithdraw: Amounts.parseOrThrow(denomIn.fee_withdraw),
isOffered: true,
masterSig: denomIn.master_sig,
stampExpireDeposit: extractTalerStampOrThrow(denomIn.stamp_expire_deposit),
stampExpireLegal: extractTalerStampOrThrow(denomIn.stamp_expire_legal),
stampExpireWithdraw: extractTalerStampOrThrow(
denomIn.stamp_expire_withdraw,
),
stampStart: extractTalerStampOrThrow(denomIn.stamp_start),
status: DenominationStatus.Unverified,
value: Amounts.parseOrThrow(denomIn.value),
};
return d;
}
async function setExchangeError(
ws: InternalWalletState,
baseUrl: string,
err: OperationError,
): Promise<void> {
const mut = (exchange: ExchangeRecord) => {
exchange.lastError = err;
return exchange;
};
await oneShotMutate(ws.db, Stores.exchanges, baseUrl, mut);
}
/**
* Fetch the exchange's /keys and update our database accordingly.
*
* Exceptions thrown in this method must be caught and reported
* in the pending operations.
*/
async function updateExchangeWithKeys(
ws: InternalWalletState,
baseUrl: string,
): Promise<void> {
const existingExchangeRecord = await oneShotGet(
ws.db,
Stores.exchanges,
baseUrl,
);
if (existingExchangeRecord?.updateStatus != ExchangeUpdateStatus.FETCH_KEYS) {
return;
}
const keysUrl = new URL("keys", baseUrl);
keysUrl.searchParams.set("cacheBreaker", WALLET_CACHE_BREAKER_CLIENT_VERSION);
let keysResp;
try {
keysResp = await ws.http.get(keysUrl.href);
} catch (e) {
const m = `Fetching keys failed: ${e.message}`;
await setExchangeError(ws, baseUrl, {
type: "network",
details: {
requestUrl: e.config?.url,
},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
let exchangeKeysJson: KeysJson;
try {
exchangeKeysJson = KeysJson.checked(keysResp.responseJson);
} catch (e) {
const m = `Parsing /keys response failed: ${e.message}`;
await setExchangeError(ws, baseUrl, {
type: "protocol-violation",
details: {},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
const lastUpdateTimestamp = extractTalerStamp(
exchangeKeysJson.list_issue_date,
);
if (!lastUpdateTimestamp) {
const m = `Parsing /keys response failed: invalid list_issue_date.`;
await setExchangeError(ws, baseUrl, {
type: "protocol-violation",
details: {},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
if (exchangeKeysJson.denoms.length === 0) {
const m = "exchange doesn't offer any denominations";
await setExchangeError(ws, baseUrl, {
type: "protocol-violation",
details: {},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
const protocolVersion = exchangeKeysJson.version;
if (!protocolVersion) {
const m = "outdate exchange, no version in /keys response";
await setExchangeError(ws, baseUrl, {
type: "protocol-violation",
details: {},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
const currency = Amounts.parseOrThrow(exchangeKeysJson.denoms[0].value)
.currency;
const newDenominations = await Promise.all(
exchangeKeysJson.denoms.map(d =>
denominationRecordFromKeys(ws, baseUrl, d),
),
);
await runWithWriteTransaction(
ws.db,
[Stores.exchanges, Stores.denominations],
async tx => {
const r = await tx.get(Stores.exchanges, baseUrl);
if (!r) {
console.warn(`exchange ${baseUrl} no longer present`);
return;
}
if (r.details) {
// FIXME: We need to do some consistency checks!
}
r.details = {
auditors: exchangeKeysJson.auditors,
currency: currency,
lastUpdateTime: lastUpdateTimestamp,
masterPublicKey: exchangeKeysJson.master_public_key,
protocolVersion: protocolVersion,
};
r.updateStatus = ExchangeUpdateStatus.FETCH_WIRE;
r.lastError = undefined;
await tx.put(Stores.exchanges, r);
for (const newDenom of newDenominations) {
const oldDenom = await tx.get(Stores.denominations, [
baseUrl,
newDenom.denomPub,
]);
if (oldDenom) {
// FIXME: Do consistency check
} else {
await tx.put(Stores.denominations, newDenom);
}
}
},
);
}
/**
* Fetch wire information for an exchange and store it in the database.
*
* @param exchangeBaseUrl Exchange base URL, assumed to be already normalized.
*/
async function updateExchangeWithWireInfo(
ws: InternalWalletState,
exchangeBaseUrl: string,
) {
const exchange = await oneShotGet(ws.db, Stores.exchanges, exchangeBaseUrl);
if (!exchange) {
return;
}
if (exchange.updateStatus != ExchangeUpdateStatus.FETCH_WIRE) {
return;
}
const reqUrl = new URL("wire", exchangeBaseUrl);
reqUrl.searchParams.set("cacheBreaker", WALLET_CACHE_BREAKER_CLIENT_VERSION)
const resp = await ws.http.get(reqUrl.href);
const wiJson = resp.responseJson;
if (!wiJson) {
throw Error("/wire response malformed");
}
const wireInfo = ExchangeWireJson.checked(wiJson);
const feesForType: { [wireMethod: string]: WireFee[] } = {};
for (const wireMethod of Object.keys(wireInfo.fees)) {
const feeList: WireFee[] = [];
for (const x of wireInfo.fees[wireMethod]) {
const startStamp = extractTalerStamp(x.start_date);
if (!startStamp) {
throw Error("wrong date format");
}
const endStamp = extractTalerStamp(x.end_date);
if (!endStamp) {
throw Error("wrong date format");
}
feeList.push({
closingFee: Amounts.parseOrThrow(x.closing_fee),
endStamp,
sig: x.sig,
startStamp,
wireFee: Amounts.parseOrThrow(x.wire_fee),
});
}
feesForType[wireMethod] = feeList;
}
await runWithWriteTransaction(ws.db, [Stores.exchanges], async tx => {
const r = await tx.get(Stores.exchanges, exchangeBaseUrl);
if (!r) {
return;
}
if (r.updateStatus != ExchangeUpdateStatus.FETCH_WIRE) {
return;
}
r.wireInfo = {
accounts: wireInfo.accounts,
feesForType: feesForType,
};
r.updateStatus = ExchangeUpdateStatus.FINISHED;
r.lastError = undefined;
await tx.put(Stores.exchanges, r);
});
}
/**
* Update or add exchange DB entry by fetching the /keys and /wire information.
* Optionally link the reserve entry to the new or existing
* exchange entry in then DB.
*/
export async function updateExchangeFromUrl(
ws: InternalWalletState,
baseUrl: string,
force: boolean = false,
): Promise<ExchangeRecord> {
const now = getTimestampNow();
baseUrl = canonicalizeBaseUrl(baseUrl);
const r = await oneShotGet(ws.db, Stores.exchanges, baseUrl);
if (!r) {
const newExchangeRecord: ExchangeRecord = {
baseUrl: baseUrl,
details: undefined,
wireInfo: undefined,
updateStatus: ExchangeUpdateStatus.FETCH_KEYS,
updateStarted: now,
updateReason: "initial",
timestampAdded: getTimestampNow(),
};
await oneShotPut(ws.db, Stores.exchanges, newExchangeRecord);
} else {
await runWithWriteTransaction(ws.db, [Stores.exchanges], async t => {
const rec = await t.get(Stores.exchanges, baseUrl);
if (!rec) {
return;
}
if (rec.updateStatus != ExchangeUpdateStatus.FETCH_KEYS && !force) {
return;
}
if (rec.updateStatus != ExchangeUpdateStatus.FETCH_KEYS && force) {
rec.updateReason = "forced";
}
rec.updateStarted = now;
rec.updateStatus = ExchangeUpdateStatus.FETCH_KEYS;
rec.lastError = undefined;
t.put(Stores.exchanges, rec);
});
}
await updateExchangeWithKeys(ws, baseUrl);
await updateExchangeWithWireInfo(ws, baseUrl);
const updatedExchange = await oneShotGet(ws.db, Stores.exchanges, baseUrl);
if (!updatedExchange) {
// This should practically never happen
throw Error("exchange not found");
}
return updatedExchange;
}
/**
* Check if and how an exchange is trusted and/or audited.
*/
export async function getExchangeTrust(
ws: InternalWalletState,
exchangeInfo: ExchangeRecord,
): Promise<{ isTrusted: boolean; isAudited: boolean }> {
let isTrusted = false;
let isAudited = false;
const exchangeDetails = exchangeInfo.details;
if (!exchangeDetails) {
throw Error(`exchange ${exchangeInfo.baseUrl} details not available`);
}
const currencyRecord = await oneShotGet(
ws.db,
Stores.currencies,
exchangeDetails.currency,
);
if (currencyRecord) {
for (const trustedExchange of currencyRecord.exchanges) {
if (trustedExchange.exchangePub === exchangeDetails.masterPublicKey) {
isTrusted = true;
break;
}
}
for (const trustedAuditor of currencyRecord.auditors) {
for (const exchangeAuditor of exchangeDetails.auditors) {
if (trustedAuditor.auditorPub === exchangeAuditor.auditor_pub) {
isAudited = true;
break;
}
}
}
}
return { isTrusted, isAudited };
}
export async function getExchangePaytoUri(
ws: InternalWalletState,
exchangeBaseUrl: string,
supportedTargetTypes: string[],
): Promise<string> {
// We do the update here, since the exchange might not even exist
// yet in our database.
const exchangeRecord = await updateExchangeFromUrl(ws, exchangeBaseUrl);
if (!exchangeRecord) {
throw Error(`Exchange '${exchangeBaseUrl}' not found.`);
}
const exchangeWireInfo = exchangeRecord.wireInfo;
if (!exchangeWireInfo) {
throw Error(`Exchange wire info for '${exchangeBaseUrl}' not found.`);
}
for (let account of exchangeWireInfo.accounts) {
const res = parsePaytoUri(account.url);
if (!res) {
continue;
}
if (supportedTargetTypes.includes(res.targetType)) {
return account.url;
}
}
throw Error("no matching exchange account found");
}

172
src/wallet-impl/history.ts Normal file
View File

@ -0,0 +1,172 @@
/*
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/>
*/
/**
* Imports.
*/
import { HistoryQuery, HistoryEvent } from "../walletTypes";
import { oneShotIter } from "../util/query";
import { InternalWalletState } from "./state";
import { Stores, TipRecord } from "../dbTypes";
import * as Amounts from "../util/amounts";
import { AmountJson } from "../util/amounts";
/**
* Retrive the full event history for this wallet.
*/
export async function getHistory(
ws: InternalWalletState,
historyQuery?: HistoryQuery,
): Promise<{ history: HistoryEvent[] }> {
const history: HistoryEvent[] = [];
// FIXME: do pagination instead of generating the full history
// We uniquely identify history rows via their timestamp.
// This works as timestamps are guaranteed to be monotonically
// increasing even
const proposals = await oneShotIter(ws.db, Stores.proposals).toArray();
for (const p of proposals) {
history.push({
detail: {
contractTermsHash: p.contractTermsHash,
merchantName: p.contractTerms.merchant.name,
},
timestamp: p.timestamp,
type: "claim-order",
explicit: false,
});
}
const withdrawals = await oneShotIter(
ws.db,
Stores.withdrawalSession,
).toArray();
for (const w of withdrawals) {
history.push({
detail: {
withdrawalAmount: w.withdrawalAmount,
},
timestamp: w.startTimestamp,
type: "withdraw",
explicit: false,
});
}
const purchases = await oneShotIter(ws.db, Stores.purchases).toArray();
for (const p of purchases) {
history.push({
detail: {
amount: p.contractTerms.amount,
contractTermsHash: p.contractTermsHash,
fulfillmentUrl: p.contractTerms.fulfillment_url,
merchantName: p.contractTerms.merchant.name,
},
timestamp: p.timestamp,
type: "pay",
explicit: false,
});
if (p.timestamp_refund) {
const contractAmount = Amounts.parseOrThrow(p.contractTerms.amount);
const amountsPending = Object.keys(p.refundsPending).map(x =>
Amounts.parseOrThrow(p.refundsPending[x].refund_amount),
);
const amountsDone = Object.keys(p.refundsDone).map(x =>
Amounts.parseOrThrow(p.refundsDone[x].refund_amount),
);
const amounts: AmountJson[] = amountsPending.concat(amountsDone);
const amount = Amounts.add(
Amounts.getZero(contractAmount.currency),
...amounts,
).amount;
history.push({
detail: {
contractTermsHash: p.contractTermsHash,
fulfillmentUrl: p.contractTerms.fulfillment_url,
merchantName: p.contractTerms.merchant.name,
refundAmount: amount,
},
timestamp: p.timestamp_refund,
type: "refund",
explicit: false,
});
}
}
const reserves = await oneShotIter(ws.db, Stores.reserves).toArray();
for (const r of reserves) {
const reserveType = r.bankWithdrawStatusUrl ? "taler-bank" : "manual";
history.push({
detail: {
exchangeBaseUrl: r.exchangeBaseUrl,
requestedAmount: Amounts.toString(r.initiallyRequestedAmount),
reservePub: r.reservePub,
reserveType,
bankWithdrawStatusUrl: r.bankWithdrawStatusUrl,
},
timestamp: r.created,
type: "reserve-created",
explicit: false,
});
if (r.timestampConfirmed) {
history.push({
detail: {
exchangeBaseUrl: r.exchangeBaseUrl,
requestedAmount: Amounts.toString(r.initiallyRequestedAmount),
reservePub: r.reservePub,
reserveType,
bankWithdrawStatusUrl: r.bankWithdrawStatusUrl,
},
timestamp: r.created,
type: "reserve-confirmed",
explicit: false,
});
}
}
const tips: TipRecord[] = await oneShotIter(ws.db, Stores.tips).toArray();
for (const tip of tips) {
history.push({
detail: {
accepted: tip.accepted,
amount: tip.amount,
merchantBaseUrl: tip.merchantBaseUrl,
tipId: tip.merchantTipId,
},
timestamp: tip.timestamp,
explicit: false,
type: "tip",
});
}
await oneShotIter(ws.db, Stores.exchanges).forEach(exchange => {
history.push({
type: "exchange-added",
explicit: false,
timestamp: exchange.timestampAdded,
detail: {
exchangeBaseUrl: exchange.baseUrl,
},
});
});
history.sort((h1, h2) => Math.sign(h1.timestamp.t_ms - h2.timestamp.t_ms));
return { history };
}

822
src/wallet-impl/pay.ts Normal file
View File

@ -0,0 +1,822 @@
/*
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/>
*/
import { AmountJson } from "../util/amounts";
import {
Auditor,
ExchangeHandle,
MerchantRefundResponse,
PayReq,
Proposal,
ContractTerms,
} from "../talerTypes";
import {
Timestamp,
CoinSelectionResult,
CoinWithDenom,
PayCoinInfo,
getTimestampNow,
PreparePayResult,
ConfirmPayResult,
} from "../walletTypes";
import {
oneShotIter,
oneShotIterIndex,
oneShotGet,
runWithWriteTransaction,
oneShotPut,
oneShotGetIndexed,
} from "../util/query";
import {
Stores,
CoinStatus,
DenominationRecord,
ProposalRecord,
PurchaseRecord,
CoinRecord,
ProposalStatus,
} from "../dbTypes";
import * as Amounts from "../util/amounts";
import {
amountToPretty,
strcmp,
extractTalerStamp,
canonicalJson,
} from "../util/helpers";
import { Logger } from "../util/logging";
import { InternalWalletState } from "./state";
import { parsePayUri } from "../util/taleruri";
import { getTotalRefreshCost, refresh } from "./refresh";
import { acceptRefundResponse } from "./refund";
import { encodeCrock, getRandomBytes } from "../crypto/talerCrypto";
export interface SpeculativePayData {
payCoinInfo: PayCoinInfo;
exchangeUrl: string;
orderDownloadId: string;
proposal: ProposalRecord;
}
interface CoinsForPaymentArgs {
allowedAuditors: Auditor[];
allowedExchanges: ExchangeHandle[];
depositFeeLimit: AmountJson;
paymentAmount: AmountJson;
wireFeeAmortization: number;
wireFeeLimit: AmountJson;
wireFeeTime: Timestamp;
wireMethod: string;
}
interface SelectPayCoinsResult {
cds: CoinWithDenom[];
totalFees: AmountJson;
}
const logger = new Logger("pay.ts");
/**
* Select coins for a payment under the merchant's constraints.
*
* @param denoms all available denoms, used to compute refresh fees
*/
export function selectPayCoins(
denoms: DenominationRecord[],
cds: CoinWithDenom[],
paymentAmount: AmountJson,
depositFeeLimit: AmountJson,
): SelectPayCoinsResult | undefined {
if (cds.length === 0) {
return undefined;
}
// Sort by ascending deposit fee and denomPub if deposit fee is the same
// (to guarantee deterministic results)
cds.sort(
(o1, o2) =>
Amounts.cmp(o1.denom.feeDeposit, o2.denom.feeDeposit) ||
strcmp(o1.denom.denomPub, o2.denom.denomPub),
);
const currency = cds[0].denom.value.currency;
const cdsResult: CoinWithDenom[] = [];
let accDepositFee: AmountJson = Amounts.getZero(currency);
let accAmount: AmountJson = Amounts.getZero(currency);
for (const { coin, denom } of cds) {
if (coin.suspended) {
continue;
}
if (coin.status !== CoinStatus.Fresh) {
continue;
}
if (Amounts.cmp(denom.feeDeposit, coin.currentAmount) >= 0) {
continue;
}
cdsResult.push({ coin, denom });
accDepositFee = Amounts.add(denom.feeDeposit, accDepositFee).amount;
let leftAmount = Amounts.sub(
coin.currentAmount,
Amounts.sub(paymentAmount, accAmount).amount,
).amount;
accAmount = Amounts.add(coin.currentAmount, accAmount).amount;
const coversAmount = Amounts.cmp(accAmount, paymentAmount) >= 0;
const coversAmountWithFee =
Amounts.cmp(
accAmount,
Amounts.add(paymentAmount, denom.feeDeposit).amount,
) >= 0;
const isBelowFee = Amounts.cmp(accDepositFee, depositFeeLimit) <= 0;
logger.trace("candidate coin selection", {
coversAmount,
isBelowFee,
accDepositFee,
accAmount,
paymentAmount,
});
if ((coversAmount && isBelowFee) || coversAmountWithFee) {
const depositFeeToCover = Amounts.sub(accDepositFee, depositFeeLimit)
.amount;
leftAmount = Amounts.sub(leftAmount, depositFeeToCover).amount;
logger.trace("deposit fee to cover", amountToPretty(depositFeeToCover));
let totalFees: AmountJson = Amounts.getZero(currency);
if (coversAmountWithFee && !isBelowFee) {
// these are the fees the customer has to pay
// because the merchant doesn't cover them
totalFees = Amounts.sub(depositFeeLimit, accDepositFee).amount;
}
totalFees = Amounts.add(
totalFees,
getTotalRefreshCost(denoms, denom, leftAmount),
).amount;
return { cds: cdsResult, totalFees };
}
}
return undefined;
}
/**
* Get exchanges and associated coins that are still spendable, but only
* if the sum the coins' remaining value covers the payment amount and fees.
*/
async function getCoinsForPayment(
ws: InternalWalletState,
args: CoinsForPaymentArgs,
): Promise<CoinSelectionResult | undefined> {
const {
allowedAuditors,
allowedExchanges,
depositFeeLimit,
paymentAmount,
wireFeeAmortization,
wireFeeLimit,
wireFeeTime,
wireMethod,
} = args;
let remainingAmount = paymentAmount;
const exchanges = await oneShotIter(ws.db, Stores.exchanges).toArray();
for (const exchange of exchanges) {
let isOkay: boolean = false;
const exchangeDetails = exchange.details;
if (!exchangeDetails) {
continue;
}
const exchangeFees = exchange.wireInfo;
if (!exchangeFees) {
continue;
}
// is the exchange explicitly allowed?
for (const allowedExchange of allowedExchanges) {
if (allowedExchange.master_pub === exchangeDetails.masterPublicKey) {
isOkay = true;
break;
}
}
// is the exchange allowed because of one of its auditors?
if (!isOkay) {
for (const allowedAuditor of allowedAuditors) {
for (const auditor of exchangeDetails.auditors) {
if (auditor.auditor_pub === allowedAuditor.auditor_pub) {
isOkay = true;
break;
}
}
if (isOkay) {
break;
}
}
}
if (!isOkay) {
continue;
}
const coins = await oneShotIterIndex(
ws.db,
Stores.coins.exchangeBaseUrlIndex,
exchange.baseUrl,
).toArray();
const denoms = await oneShotIterIndex(
ws.db,
Stores.denominations.exchangeBaseUrlIndex,
exchange.baseUrl,
).toArray();
if (!coins || coins.length === 0) {
continue;
}
// Denomination of the first coin, we assume that all other
// coins have the same currency
const firstDenom = await oneShotGet(ws.db, Stores.denominations, [
exchange.baseUrl,
coins[0].denomPub,
]);
if (!firstDenom) {
throw Error("db inconsistent");
}
const currency = firstDenom.value.currency;
const cds: CoinWithDenom[] = [];
for (const coin of coins) {
const denom = await oneShotGet(ws.db, Stores.denominations, [
exchange.baseUrl,
coin.denomPub,
]);
if (!denom) {
throw Error("db inconsistent");
}
if (denom.value.currency !== currency) {
console.warn(
`same pubkey for different currencies at exchange ${exchange.baseUrl}`,
);
continue;
}
if (coin.suspended) {
continue;
}
if (coin.status !== CoinStatus.Fresh) {
continue;
}
cds.push({ coin, denom });
}
let totalFees = Amounts.getZero(currency);
let wireFee: AmountJson | undefined;
for (const fee of exchangeFees.feesForType[wireMethod] || []) {
if (fee.startStamp <= wireFeeTime && fee.endStamp >= wireFeeTime) {
wireFee = fee.wireFee;
break;
}
}
if (wireFee) {
const amortizedWireFee = Amounts.divide(wireFee, wireFeeAmortization);
if (Amounts.cmp(wireFeeLimit, amortizedWireFee) < 0) {
totalFees = Amounts.add(amortizedWireFee, totalFees).amount;
remainingAmount = Amounts.add(amortizedWireFee, remainingAmount).amount;
}
}
const res = selectPayCoins(denoms, cds, remainingAmount, depositFeeLimit);
if (res) {
totalFees = Amounts.add(totalFees, res.totalFees).amount;
return {
cds: res.cds,
exchangeUrl: exchange.baseUrl,
totalAmount: remainingAmount,
totalFees,
};
}
}
return undefined;
}
/**
* Record all information that is necessary to
* pay for a proposal in the wallet's database.
*/
async function recordConfirmPay(
ws: InternalWalletState,
proposal: ProposalRecord,
payCoinInfo: PayCoinInfo,
chosenExchange: string,
): Promise<PurchaseRecord> {
const payReq: PayReq = {
coins: payCoinInfo.sigs,
merchant_pub: proposal.contractTerms.merchant_pub,
mode: "pay",
order_id: proposal.contractTerms.order_id,
};
const t: PurchaseRecord = {
abortDone: false,
abortRequested: false,
contractTerms: proposal.contractTerms,
contractTermsHash: proposal.contractTermsHash,
finished: false,
lastSessionId: undefined,
merchantSig: proposal.merchantSig,
payReq,
refundsDone: {},
refundsPending: {},
timestamp: getTimestampNow(),
timestamp_refund: undefined,
};
await runWithWriteTransaction(
ws.db,
[Stores.coins, Stores.purchases],
async tx => {
await tx.put(Stores.purchases, t);
for (let c of payCoinInfo.updatedCoins) {
await tx.put(Stores.coins, c);
}
},
);
ws.badge.showNotification();
ws.notifier.notify();
return t;
}
function getNextUrl(contractTerms: ContractTerms): string {
const fu = new URL(contractTerms.fulfillment_url)
fu.searchParams.set("order_id", contractTerms.order_id);
return fu.href;
}
export async function abortFailedPayment(
ws: InternalWalletState,
contractTermsHash: string,
): Promise<void> {
const purchase = await oneShotGet(ws.db, Stores.purchases, contractTermsHash);
if (!purchase) {
throw Error("Purchase not found, unable to abort with refund");
}
if (purchase.finished) {
throw Error("Purchase already finished, not aborting");
}
if (purchase.abortDone) {
console.warn("abort requested on already aborted purchase");
return;
}
purchase.abortRequested = true;
// From now on, we can't retry payment anymore,
// so mark this in the DB in case the /pay abort
// does not complete on the first try.
await oneShotPut(ws.db, Stores.purchases, purchase);
let resp;
const abortReq = { ...purchase.payReq, mode: "abort-refund" };
const payUrl = new URL("pay", purchase.contractTerms.merchant_base_url).href;
try {
resp = await ws.http.postJson(payUrl, abortReq);
} catch (e) {
// Gives the user the option to retry / abort and refresh
console.log("aborting payment failed", e);
throw e;
}
const refundResponse = MerchantRefundResponse.checked(resp.responseJson);
await acceptRefundResponse(ws, refundResponse);
await runWithWriteTransaction(ws.db, [Stores.purchases], async tx => {
const p = await tx.get(Stores.purchases, purchase.contractTermsHash);
if (!p) {
return;
}
p.abortDone = true;
await tx.put(Stores.purchases, p);
});
}
/**
* Download a proposal and store it in the database.
* Returns an id for it to retrieve it later.
*
* @param sessionId Current session ID, if the proposal is being
* downloaded in the context of a session ID.
*/
async function downloadProposal(
ws: InternalWalletState,
url: string,
sessionId?: string,
): Promise<string> {
const oldProposal = await oneShotGetIndexed(
ws.db,
Stores.proposals.urlIndex,
url,
);
if (oldProposal) {
return oldProposal.proposalId;
}
const { priv, pub } = await ws.cryptoApi.createEddsaKeypair();
const parsed_url = new URL(url);
parsed_url.searchParams.set("nonce", pub);
const urlWithNonce = parsed_url.href;
console.log("downloading contract from '" + urlWithNonce + "'");
let resp;
try {
resp = await ws.http.get(urlWithNonce);
} catch (e) {
console.log("contract download failed", e);
throw e;
}
const proposal = Proposal.checked(resp.responseJson);
const contractTermsHash = await ws.cryptoApi.hashString(
canonicalJson(proposal.contract_terms),
);
const proposalId = encodeCrock(getRandomBytes(32));
const proposalRecord: ProposalRecord = {
contractTerms: proposal.contract_terms,
contractTermsHash,
merchantSig: proposal.sig,
noncePriv: priv,
timestamp: getTimestampNow(),
url,
downloadSessionId: sessionId,
proposalId: proposalId,
proposalStatus: ProposalStatus.PROPOSED,
};
await oneShotPut(ws.db, Stores.proposals, proposalRecord);
ws.notifier.notify();
return proposalId;
}
async function submitPay(
ws: InternalWalletState,
contractTermsHash: string,
sessionId: string | undefined,
): Promise<ConfirmPayResult> {
const purchase = await oneShotGet(ws.db, Stores.purchases, contractTermsHash);
if (!purchase) {
throw Error("Purchase not found: " + contractTermsHash);
}
if (purchase.abortRequested) {
throw Error("not submitting payment for aborted purchase");
}
let resp;
const payReq = { ...purchase.payReq, session_id: sessionId };
const payUrl = new URL("pay", purchase.contractTerms.merchant_base_url).href;
try {
resp = await ws.http.postJson(payUrl, payReq);
} catch (e) {
// Gives the user the option to retry / abort and refresh
console.log("payment failed", e);
throw e;
}
const merchantResp = resp.responseJson;
console.log("got success from pay URL");
const merchantPub = purchase.contractTerms.merchant_pub;
const valid: boolean = await ws.cryptoApi.isValidPaymentSignature(
merchantResp.sig,
contractTermsHash,
merchantPub,
);
if (!valid) {
console.error("merchant payment signature invalid");
// FIXME: properly display error
throw Error("merchant payment signature invalid");
}
purchase.finished = true;
const modifiedCoins: CoinRecord[] = [];
for (const pc of purchase.payReq.coins) {
const c = await oneShotGet(ws.db, Stores.coins, pc.coin_pub);
if (!c) {
console.error("coin not found");
throw Error("coin used in payment not found");
}
c.status = CoinStatus.Dirty;
modifiedCoins.push(c);
}
await runWithWriteTransaction(
ws.db,
[Stores.coins, Stores.purchases],
async tx => {
for (let c of modifiedCoins) {
tx.put(Stores.coins, c);
}
tx.put(Stores.purchases, purchase);
},
);
for (const c of purchase.payReq.coins) {
refresh(ws, c.coin_pub);
}
const nextUrl = getNextUrl(purchase.contractTerms);
ws.cachedNextUrl[purchase.contractTerms.fulfillment_url] = {
nextUrl,
lastSessionId: sessionId,
};
return { nextUrl };
}
/**
* Check if a payment for the given taler://pay/ URI is possible.
*
* If the payment is possible, the signature are already generated but not
* yet send to the merchant.
*/
export async function preparePay(
ws: InternalWalletState,
talerPayUri: string,
): Promise<PreparePayResult> {
const uriResult = parsePayUri(talerPayUri);
if (!uriResult) {
return {
status: "error",
error: "URI not supported",
};
}
let proposalId: string;
try {
proposalId = await downloadProposal(
ws,
uriResult.downloadUrl,
uriResult.sessionId,
);
} catch (e) {
return {
status: "error",
error: e.toString(),
};
}
const proposal = await oneShotGet(ws.db, Stores.proposals, proposalId);
if (!proposal) {
throw Error(`could not get proposal ${proposalId}`);
}
console.log("proposal", proposal);
const differentPurchase = await oneShotGetIndexed(
ws.db,
Stores.purchases.fulfillmentUrlIndex,
proposal.contractTerms.fulfillment_url,
);
let fulfillmentUrl = proposal.contractTerms.fulfillment_url;
let doublePurchaseDetection = false;
if (fulfillmentUrl.startsWith("http")) {
doublePurchaseDetection = true;
}
if (differentPurchase && doublePurchaseDetection) {
// We do this check to prevent merchant B to find out if we bought a
// digital product with merchant A by abusing the existing payment
// redirect feature.
if (
differentPurchase.contractTerms.merchant_pub !=
proposal.contractTerms.merchant_pub
) {
console.warn(
"merchant with different public key offered contract with same fulfillment URL as an existing purchase",
);
} else {
if (uriResult.sessionId) {
await submitPay(
ws,
differentPurchase.contractTermsHash,
uriResult.sessionId,
);
}
return {
status: "paid",
contractTerms: differentPurchase.contractTerms,
nextUrl: getNextUrl(differentPurchase.contractTerms),
};
}
}
// First check if we already payed for it.
const purchase = await oneShotGet(
ws.db,
Stores.purchases,
proposal.contractTermsHash,
);
if (!purchase) {
const paymentAmount = Amounts.parseOrThrow(proposal.contractTerms.amount);
let wireFeeLimit;
if (proposal.contractTerms.max_wire_fee) {
wireFeeLimit = Amounts.parseOrThrow(proposal.contractTerms.max_wire_fee);
} else {
wireFeeLimit = Amounts.getZero(paymentAmount.currency);
}
// If not already payed, check if we could pay for it.
const res = await getCoinsForPayment(ws, {
allowedAuditors: proposal.contractTerms.auditors,
allowedExchanges: proposal.contractTerms.exchanges,
depositFeeLimit: Amounts.parseOrThrow(proposal.contractTerms.max_fee),
paymentAmount,
wireFeeAmortization: proposal.contractTerms.wire_fee_amortization || 1,
wireFeeLimit,
// FIXME: parse this properly
wireFeeTime: extractTalerStamp(proposal.contractTerms.timestamp) || {
t_ms: 0,
},
wireMethod: proposal.contractTerms.wire_method,
});
if (!res) {
console.log("not confirming payment, insufficient coins");
return {
status: "insufficient-balance",
contractTerms: proposal.contractTerms,
proposalId: proposal.proposalId,
};
}
// Only create speculative signature if we don't already have one for this proposal
if (
!ws.speculativePayData ||
(ws.speculativePayData &&
ws.speculativePayData.orderDownloadId !== proposalId)
) {
const { exchangeUrl, cds, totalAmount } = res;
const payCoinInfo = await ws.cryptoApi.signDeposit(
proposal.contractTerms,
cds,
totalAmount,
);
ws.speculativePayData = {
exchangeUrl,
payCoinInfo,
proposal,
orderDownloadId: proposalId,
};
logger.trace("created speculative pay data for payment");
}
return {
status: "payment-possible",
contractTerms: proposal.contractTerms,
proposalId: proposal.proposalId,
totalFees: res.totalFees,
};
}
if (uriResult.sessionId) {
await submitPay(ws, purchase.contractTermsHash, uriResult.sessionId);
}
return {
status: "paid",
contractTerms: proposal.contractTerms,
nextUrl: getNextUrl(purchase.contractTerms),
};
}
/**
* Get the speculative pay data, but only if coins have not changed in between.
*/
async function getSpeculativePayData(
ws: InternalWalletState,
proposalId: string,
): Promise<SpeculativePayData | undefined> {
const sp = ws.speculativePayData;
if (!sp) {
return;
}
if (sp.orderDownloadId !== proposalId) {
return;
}
const coinKeys = sp.payCoinInfo.updatedCoins.map(x => x.coinPub);
const coins: CoinRecord[] = [];
for (let coinKey of coinKeys) {
const cc = await oneShotGet(ws.db, Stores.coins, coinKey);
if (cc) {
coins.push(cc);
}
}
for (let i = 0; i < coins.length; i++) {
const specCoin = sp.payCoinInfo.originalCoins[i];
const currentCoin = coins[i];
// Coin does not exist anymore!
if (!currentCoin) {
return;
}
if (Amounts.cmp(specCoin.currentAmount, currentCoin.currentAmount) !== 0) {
return;
}
}
return sp;
}
/**
* Add a contract to the wallet and sign coins, and send them.
*/
export async function confirmPay(
ws: InternalWalletState,
proposalId: string,
sessionIdOverride: string | undefined,
): Promise<ConfirmPayResult> {
logger.trace(
`executing confirmPay with proposalId ${proposalId} and sessionIdOverride ${sessionIdOverride}`,
);
const proposal = await oneShotGet(ws.db, Stores.proposals, proposalId);
if (!proposal) {
throw Error(`proposal with id ${proposalId} not found`);
}
const sessionId = sessionIdOverride || proposal.downloadSessionId;
let purchase = await oneShotGet(
ws.db,
Stores.purchases,
proposal.contractTermsHash,
);
if (purchase) {
return submitPay(ws, purchase.contractTermsHash, sessionId);
}
const contractAmount = Amounts.parseOrThrow(proposal.contractTerms.amount);
let wireFeeLimit;
if (!proposal.contractTerms.max_wire_fee) {
wireFeeLimit = Amounts.getZero(contractAmount.currency);
} else {
wireFeeLimit = Amounts.parseOrThrow(proposal.contractTerms.max_wire_fee);
}
const res = await getCoinsForPayment(ws, {
allowedAuditors: proposal.contractTerms.auditors,
allowedExchanges: proposal.contractTerms.exchanges,
depositFeeLimit: Amounts.parseOrThrow(proposal.contractTerms.max_fee),
paymentAmount: Amounts.parseOrThrow(proposal.contractTerms.amount),
wireFeeAmortization: proposal.contractTerms.wire_fee_amortization || 1,
wireFeeLimit,
// FIXME: parse this properly
wireFeeTime: extractTalerStamp(proposal.contractTerms.timestamp) || {
t_ms: 0,
},
wireMethod: proposal.contractTerms.wire_method,
});
logger.trace("coin selection result", res);
if (!res) {
// Should not happen, since checkPay should be called first
console.log("not confirming payment, insufficient coins");
throw Error("insufficient balance");
}
const sd = await getSpeculativePayData(ws, proposalId);
if (!sd) {
const { exchangeUrl, cds, totalAmount } = res;
const payCoinInfo = await ws.cryptoApi.signDeposit(
proposal.contractTerms,
cds,
totalAmount,
);
purchase = await recordConfirmPay(ws, proposal, payCoinInfo, exchangeUrl);
} else {
purchase = await recordConfirmPay(
ws,
sd.proposal,
sd.payCoinInfo,
sd.exchangeUrl,
);
}
return submitPay(ws, purchase.contractTermsHash, sessionId);
}

88
src/wallet-impl/payback.ts Normal file
View File

@ -0,0 +1,88 @@
/*
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/>
*/
/**
* Imports.
*/
import {
oneShotIter,
runWithWriteTransaction,
oneShotGet,
oneShotPut,
} from "../util/query";
import { InternalWalletState } from "./state";
import { Stores, TipRecord, CoinStatus } from "../dbTypes";
import { Logger } from "../util/logging";
import { PaybackConfirmation } from "../talerTypes";
import { updateExchangeFromUrl } from "./exchanges";
const logger = new Logger("payback.ts");
export async function payback(
ws: InternalWalletState,
coinPub: string,
): Promise<void> {
let coin = await oneShotGet(ws.db, Stores.coins, coinPub);
if (!coin) {
throw Error(`Coin ${coinPub} not found, can't request payback`);
}
const reservePub = coin.reservePub;
if (!reservePub) {
throw Error(`Can't request payback for a refreshed coin`);
}
const reserve = await oneShotGet(ws.db, Stores.reserves, reservePub);
if (!reserve) {
throw Error(`Reserve of coin ${coinPub} not found`);
}
switch (coin.status) {
case CoinStatus.Dormant:
throw Error(`Can't do payback for coin ${coinPub} since it's dormant`);
}
coin.status = CoinStatus.Dormant;
// Even if we didn't get the payback yet, we suspend withdrawal, since
// technically we might update reserve status before we get the response
// from the reserve for the payback request.
reserve.hasPayback = true;
await runWithWriteTransaction(
ws.db,
[Stores.coins, Stores.reserves],
async tx => {
await tx.put(Stores.coins, coin!!);
await tx.put(Stores.reserves, reserve);
},
);
ws.notifier.notify();
const paybackRequest = await ws.cryptoApi.createPaybackRequest(coin);
const reqUrl = new URL("payback", coin.exchangeBaseUrl);
const resp = await ws.http.postJson(reqUrl.href, paybackRequest);
if (resp.status !== 200) {
throw Error();
}
const paybackConfirmation = PaybackConfirmation.checked(resp.responseJson);
if (paybackConfirmation.reserve_pub !== coin.reservePub) {
throw Error(`Coin's reserve doesn't match reserve on payback`);
}
coin = await oneShotGet(ws.db, Stores.coins, coinPub);
if (!coin) {
throw Error(`Coin ${coinPub} not found, can't confirm payback`);
}
coin.status = CoinStatus.Dormant;
await oneShotPut(ws.db, Stores.coins, coin);
ws.notifier.notify();
await updateExchangeFromUrl(ws, coin.exchangeBaseUrl, true);
}

208
src/wallet-impl/pending.ts Normal file
View File

@ -0,0 +1,208 @@
/*
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/>
*/
/**
* Imports.
*/
import { PendingOperationInfo, PendingOperationsResponse } from "../walletTypes";
import { oneShotIter } from "../util/query";
import { InternalWalletState } from "./state";
import { Stores, ExchangeUpdateStatus, ReserveRecordStatus, CoinStatus, ProposalStatus } from "../dbTypes";
export async function getPendingOperations(
ws: InternalWalletState,
): Promise<PendingOperationsResponse> {
const pendingOperations: PendingOperationInfo[] = [];
const exchanges = await oneShotIter(ws.db, Stores.exchanges).toArray();
for (let e of exchanges) {
switch (e.updateStatus) {
case ExchangeUpdateStatus.FINISHED:
if (e.lastError) {
pendingOperations.push({
type: "bug",
message:
"Exchange record is in FINISHED state but has lastError set",
details: {
exchangeBaseUrl: e.baseUrl,
},
});
}
if (!e.details) {
pendingOperations.push({
type: "bug",
message:
"Exchange record does not have details, but no update in progress.",
details: {
exchangeBaseUrl: e.baseUrl,
},
});
}
if (!e.wireInfo) {
pendingOperations.push({
type: "bug",
message:
"Exchange record does not have wire info, but no update in progress.",
details: {
exchangeBaseUrl: e.baseUrl,
},
});
}
break;
case ExchangeUpdateStatus.FETCH_KEYS:
pendingOperations.push({
type: "exchange-update",
stage: "fetch-keys",
exchangeBaseUrl: e.baseUrl,
lastError: e.lastError,
reason: e.updateReason || "unknown",
});
break;
case ExchangeUpdateStatus.FETCH_WIRE:
pendingOperations.push({
type: "exchange-update",
stage: "fetch-wire",
exchangeBaseUrl: e.baseUrl,
lastError: e.lastError,
reason: e.updateReason || "unknown",
});
break;
default:
pendingOperations.push({
type: "bug",
message: "Unknown exchangeUpdateStatus",
details: {
exchangeBaseUrl: e.baseUrl,
exchangeUpdateStatus: e.updateStatus,
},
});
break;
}
}
await oneShotIter(ws.db, Stores.reserves).forEach(reserve => {
const reserveType = reserve.bankWithdrawStatusUrl
? "taler-bank"
: "manual";
switch (reserve.reserveStatus) {
case ReserveRecordStatus.DORMANT:
// nothing to report as pending
break;
case ReserveRecordStatus.WITHDRAWING:
case ReserveRecordStatus.UNCONFIRMED:
case ReserveRecordStatus.QUERYING_STATUS:
case ReserveRecordStatus.REGISTERING_BANK:
pendingOperations.push({
type: "reserve",
stage: reserve.reserveStatus,
timestampCreated: reserve.created,
reserveType,
reservePub: reserve.reservePub,
});
break;
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
pendingOperations.push({
type: "reserve",
stage: reserve.reserveStatus,
timestampCreated: reserve.created,
reserveType,
reservePub: reserve.reservePub,
bankWithdrawConfirmUrl: reserve.bankWithdrawConfirmUrl,
});
break;
default:
pendingOperations.push({
type: "bug",
message: "Unknown reserve record status",
details: {
reservePub: reserve.reservePub,
reserveStatus: reserve.reserveStatus,
},
});
break;
}
});
await oneShotIter(ws.db, Stores.refresh).forEach(r => {
if (r.finished) {
return;
}
let refreshStatus: string;
if (r.norevealIndex === undefined) {
refreshStatus = "melt";
} else {
refreshStatus = "reveal";
}
pendingOperations.push({
type: "refresh",
oldCoinPub: r.meltCoinPub,
refreshStatus,
refreshOutputSize: r.newDenoms.length,
refreshSessionId: r.refreshSessionId,
});
});
await oneShotIter(ws.db, Stores.coins).forEach(coin => {
if (coin.status == CoinStatus.Dirty) {
pendingOperations.push({
type: "dirty-coin",
coinPub: coin.coinPub,
});
}
});
await oneShotIter(ws.db, Stores.withdrawalSession).forEach(ws => {
const numCoinsWithdrawn = ws.withdrawn.reduce(
(a, x) => a + (x ? 1 : 0),
0,
);
const numCoinsTotal = ws.withdrawn.length;
if (numCoinsWithdrawn < numCoinsTotal) {
pendingOperations.push({
type: "withdraw",
numCoinsTotal,
numCoinsWithdrawn,
source: ws.source,
withdrawSessionId: ws.withdrawSessionId,
});
}
});
await oneShotIter(ws.db, Stores.proposals).forEach(proposal => {
if (proposal.proposalStatus == ProposalStatus.PROPOSED) {
pendingOperations.push({
type: "proposal",
merchantBaseUrl: proposal.contractTerms.merchant_base_url,
proposalId: proposal.proposalId,
proposalTimestamp: proposal.timestamp,
});
}
});
await oneShotIter(ws.db, Stores.tips).forEach(tip => {
if (tip.accepted && !tip.pickedUp) {
pendingOperations.push({
type: "tip",
merchantBaseUrl: tip.merchantBaseUrl,
tipId: tip.tipId,
merchantTipId: tip.merchantTipId,
});
}
});
return {
pendingOperations,
};
}

416
src/wallet-impl/refresh.ts Normal file
View File

@ -0,0 +1,416 @@
/*
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/>
*/
import { AmountJson } from "../util/amounts";
import * as Amounts from "../util/amounts";
import {
DenominationRecord,
Stores,
CoinStatus,
RefreshPlanchetRecord,
CoinRecord,
RefreshSessionRecord,
} from "../dbTypes";
import { amountToPretty } from "../util/helpers";
import {
oneShotGet,
oneShotMutate,
runWithWriteTransaction,
TransactionAbort,
oneShotIterIndex,
} from "../util/query";
import { InternalWalletState } from "./state";
import { Logger } from "../util/logging";
import { getWithdrawDenomList } from "./withdraw";
import { updateExchangeFromUrl } from "./exchanges";
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;
const withdrawDenoms = getWithdrawDenomList(withdrawAmount, denoms);
const resultingAmount = Amounts.add(
Amounts.getZero(withdrawAmount.currency),
...withdrawDenoms.map(d => d.value),
).amount;
const totalCost = Amounts.sub(amountLeft, resultingAmount).amount;
logger.trace(
"total refresh cost for",
amountToPretty(amountLeft),
"is",
amountToPretty(totalCost),
);
return totalCost;
}
async function refreshMelt(
ws: InternalWalletState,
refreshSessionId: string,
): Promise<void> {
const refreshSession = await oneShotGet(
ws.db,
Stores.refresh,
refreshSessionId,
);
if (!refreshSession) {
return;
}
if (refreshSession.norevealIndex !== undefined) {
return;
}
const coin = await oneShotGet(
ws.db,
Stores.coins,
refreshSession.meltCoinPub,
);
if (!coin) {
console.error("can't melt coin, it does not exist");
return;
}
const reqUrl = new URL("refresh/melt", refreshSession.exchangeBaseUrl);
const meltReq = {
coin_pub: coin.coinPub,
confirm_sig: refreshSession.confirmSig,
denom_pub_hash: coin.denomPubHash,
denom_sig: coin.denomSig,
rc: refreshSession.hash,
value_with_fee: refreshSession.valueWithFee,
};
logger.trace("melt request:", meltReq);
const resp = await ws.http.postJson(reqUrl.href, meltReq);
logger.trace("melt response:", resp.responseJson);
if (resp.status !== 200) {
console.error(resp.responseJson);
throw Error("refresh failed");
}
const respJson = resp.responseJson;
const norevealIndex = respJson.noreveal_index;
if (typeof norevealIndex !== "number") {
throw Error("invalid response");
}
refreshSession.norevealIndex = norevealIndex;
await oneShotMutate(ws.db, Stores.refresh, refreshSessionId, rs => {
if (rs.norevealIndex !== undefined) {
return;
}
if (rs.finished) {
return;
}
rs.norevealIndex = norevealIndex;
return rs;
});
ws.notifier.notify();
}
async function refreshReveal(
ws: InternalWalletState,
refreshSessionId: string,
): Promise<void> {
const refreshSession = await oneShotGet(
ws.db,
Stores.refresh,
refreshSessionId,
);
if (!refreshSession) {
return;
}
const norevealIndex = refreshSession.norevealIndex;
if (norevealIndex === undefined) {
throw Error("can't reveal without melting first");
}
const privs = Array.from(refreshSession.transferPrivs);
privs.splice(norevealIndex, 1);
const planchets = refreshSession.planchetsForGammas[norevealIndex];
if (!planchets) {
throw Error("refresh index error");
}
const meltCoinRecord = await oneShotGet(
ws.db,
Stores.coins,
refreshSession.meltCoinPub,
);
if (!meltCoinRecord) {
throw Error("inconsistent database");
}
const evs = planchets.map((x: RefreshPlanchetRecord) => x.coinEv);
const linkSigs: string[] = [];
for (let i = 0; i < refreshSession.newDenoms.length; i++) {
const linkSig = await ws.cryptoApi.signCoinLink(
meltCoinRecord.coinPriv,
refreshSession.newDenomHashes[i],
refreshSession.meltCoinPub,
refreshSession.transferPubs[norevealIndex],
planchets[i].coinEv,
);
linkSigs.push(linkSig);
}
const req = {
coin_evs: evs,
new_denoms_h: refreshSession.newDenomHashes,
rc: refreshSession.hash,
transfer_privs: privs,
transfer_pub: refreshSession.transferPubs[norevealIndex],
link_sigs: linkSigs,
};
const reqUrl = new URL("refresh/reveal", refreshSession.exchangeBaseUrl);
logger.trace("reveal request:", req);
let resp;
try {
resp = await ws.http.postJson(reqUrl.href, req);
} catch (e) {
console.error("got error during /refresh/reveal request");
console.error(e);
return;
}
logger.trace("session:", refreshSession);
logger.trace("reveal response:", resp);
if (resp.status !== 200) {
console.error("error: /refresh/reveal returned status " + resp.status);
return;
}
const respJson = resp.responseJson;
if (!respJson.ev_sigs || !Array.isArray(respJson.ev_sigs)) {
console.error("/refresh/reveal did not contain ev_sigs");
return;
}
const exchange = oneShotGet(
ws.db,
Stores.exchanges,
refreshSession.exchangeBaseUrl,
);
if (!exchange) {
console.error(`exchange ${refreshSession.exchangeBaseUrl} not found`);
return;
}
const coins: CoinRecord[] = [];
for (let i = 0; i < respJson.ev_sigs.length; i++) {
const denom = await oneShotGet(ws.db, Stores.denominations, [
refreshSession.exchangeBaseUrl,
refreshSession.newDenoms[i],
]);
if (!denom) {
console.error("denom not found");
continue;
}
const pc =
refreshSession.planchetsForGammas[refreshSession.norevealIndex!][i];
const denomSig = await ws.cryptoApi.rsaUnblind(
respJson.ev_sigs[i].ev_sig,
pc.blindingKey,
denom.denomPub,
);
const coin: CoinRecord = {
blindingKey: pc.blindingKey,
coinPriv: pc.privateKey,
coinPub: pc.publicKey,
currentAmount: denom.value,
denomPub: denom.denomPub,
denomPubHash: denom.denomPubHash,
denomSig,
exchangeBaseUrl: refreshSession.exchangeBaseUrl,
reservePub: undefined,
status: CoinStatus.Fresh,
coinIndex: -1,
withdrawSessionId: "",
};
coins.push(coin);
}
refreshSession.finished = true;
await runWithWriteTransaction(
ws.db,
[Stores.coins, Stores.refresh],
async tx => {
const rs = await tx.get(Stores.refresh, refreshSessionId);
if (!rs) {
return;
}
if (rs.finished) {
return;
}
for (let coin of coins) {
await tx.put(Stores.coins, coin);
}
await tx.put(Stores.refresh, refreshSession);
},
);
ws.notifier.notify();
}
export async function processRefreshSession(
ws: InternalWalletState,
refreshSessionId: string,
) {
const refreshSession = await oneShotGet(
ws.db,
Stores.refresh,
refreshSessionId,
);
if (!refreshSession) {
return;
}
if (refreshSession.finished) {
return;
}
if (typeof refreshSession.norevealIndex !== "number") {
await refreshMelt(ws, refreshSession.refreshSessionId);
}
await refreshReveal(ws, refreshSession.refreshSessionId);
logger.trace("refresh finished");
}
export async function refresh(
ws: InternalWalletState,
oldCoinPub: string,
force: boolean = false,
): Promise<void> {
const coin = await oneShotGet(ws.db, Stores.coins, oldCoinPub);
if (!coin) {
console.warn("can't refresh, coin not in database");
return;
}
switch (coin.status) {
case CoinStatus.Dirty:
break;
case CoinStatus.Dormant:
return;
case CoinStatus.Fresh:
if (!force) {
return;
}
break;
}
const exchange = await updateExchangeFromUrl(ws, coin.exchangeBaseUrl);
if (!exchange) {
throw Error("db inconsistent: exchange of coin not found");
}
const oldDenom = await oneShotGet(ws.db, Stores.denominations, [
exchange.baseUrl,
coin.denomPub,
]);
if (!oldDenom) {
throw Error("db inconsistent: denomination for coin not found");
}
const availableDenoms: DenominationRecord[] = await oneShotIterIndex(
ws.db,
Stores.denominations.exchangeBaseUrlIndex,
exchange.baseUrl,
).toArray();
const availableAmount = Amounts.sub(coin.currentAmount, oldDenom.feeRefresh)
.amount;
const newCoinDenoms = getWithdrawDenomList(availableAmount, availableDenoms);
if (newCoinDenoms.length === 0) {
logger.trace(
`not refreshing, available amount ${amountToPretty(
availableAmount,
)} too small`,
);
await oneShotMutate(ws.db, Stores.coins, oldCoinPub, x => {
if (x.status != coin.status) {
// Concurrent modification?
return;
}
x.status = CoinStatus.Dormant;
return x;
});
ws.notifier.notify();
return;
}
const refreshSession: RefreshSessionRecord = await ws.cryptoApi.createRefreshSession(
exchange.baseUrl,
3,
coin,
newCoinDenoms,
oldDenom.feeRefresh,
);
function mutateCoin(c: CoinRecord): CoinRecord {
const r = Amounts.sub(c.currentAmount, refreshSession.valueWithFee);
if (r.saturated) {
// Something else must have written the coin value
throw TransactionAbort;
}
c.currentAmount = r.amount;
c.status = CoinStatus.Dormant;
return c;
}
// Store refresh session and subtract refreshed amount from
// coin in the same transaction.
await runWithWriteTransaction(
ws.db,
[Stores.refresh, Stores.coins],
async tx => {
await tx.put(Stores.refresh, refreshSession);
await tx.mutate(Stores.coins, coin.coinPub, mutateCoin);
},
);
logger.info(`created refresh session ${refreshSession.refreshSessionId}`);
ws.notifier.notify();
await processRefreshSession(ws, refreshSession.refreshSessionId);
}

245
src/wallet-impl/refund.ts Normal file
View File

@ -0,0 +1,245 @@
/*
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/>
*/
import {
MerchantRefundResponse,
RefundRequest,
MerchantRefundPermission,
} from "../talerTypes";
import { PurchaseRecord, Stores, CoinRecord, CoinStatus } from "../dbTypes";
import { getTimestampNow } from "../walletTypes";
import {
oneShotMutate,
oneShotGet,
runWithWriteTransaction,
oneShotIterIndex,
} from "../util/query";
import { InternalWalletState } from "./state";
import { parseRefundUri } from "../util/taleruri";
import { Logger } from "../util/logging";
import { AmountJson } from "../util/amounts";
import * as Amounts from "../util/amounts";
import { getTotalRefreshCost, refresh } from "./refresh";
const logger = new Logger("refund.ts");
export async function getFullRefundFees(
ws: InternalWalletState,
refundPermissions: MerchantRefundPermission[],
): Promise<AmountJson> {
if (refundPermissions.length === 0) {
throw Error("no refunds given");
}
const coin0 = await oneShotGet(
ws.db,
Stores.coins,
refundPermissions[0].coin_pub,
);
if (!coin0) {
throw Error("coin not found");
}
let feeAcc = Amounts.getZero(
Amounts.parseOrThrow(refundPermissions[0].refund_amount).currency,
);
const denoms = await oneShotIterIndex(
ws.db,
Stores.denominations.exchangeBaseUrlIndex,
coin0.exchangeBaseUrl,
).toArray();
for (const rp of refundPermissions) {
const coin = await oneShotGet(ws.db, Stores.coins, rp.coin_pub);
if (!coin) {
throw Error("coin not found");
}
const denom = await oneShotGet(ws.db, Stores.denominations, [
coin0.exchangeBaseUrl,
coin.denomPub,
]);
if (!denom) {
throw Error(`denom not found (${coin.denomPub})`);
}
// FIXME: this assumes that the refund already happened.
// When it hasn't, the refresh cost is inaccurate. To fix this,
// we need introduce a flag to tell if a coin was refunded or
// refreshed normally (and what about incremental refunds?)
const refundAmount = Amounts.parseOrThrow(rp.refund_amount);
const refundFee = Amounts.parseOrThrow(rp.refund_fee);
const refreshCost = getTotalRefreshCost(
denoms,
denom,
Amounts.sub(refundAmount, refundFee).amount,
);
feeAcc = Amounts.add(feeAcc, refreshCost, refundFee).amount;
}
return feeAcc;
}
async function submitRefunds(
ws: InternalWalletState,
contractTermsHash: string,
): Promise<void> {
const purchase = await oneShotGet(ws.db, Stores.purchases, contractTermsHash);
if (!purchase) {
console.error(
"not submitting refunds, contract terms not found:",
contractTermsHash,
);
return;
}
const pendingKeys = Object.keys(purchase.refundsPending);
if (pendingKeys.length === 0) {
return;
}
for (const pk of pendingKeys) {
const perm = purchase.refundsPending[pk];
const req: RefundRequest = {
coin_pub: perm.coin_pub,
h_contract_terms: purchase.contractTermsHash,
merchant_pub: purchase.contractTerms.merchant_pub,
merchant_sig: perm.merchant_sig,
refund_amount: perm.refund_amount,
refund_fee: perm.refund_fee,
rtransaction_id: perm.rtransaction_id,
};
console.log("sending refund permission", perm);
// FIXME: not correct once we support multiple exchanges per payment
const exchangeUrl = purchase.payReq.coins[0].exchange_url;
const reqUrl = new URL("refund", exchangeUrl);
const resp = await ws.http.postJson(reqUrl.href, req);
if (resp.status !== 200) {
console.error("refund failed", resp);
continue;
}
// Transactionally mark successful refunds as done
const transformPurchase = (
t: PurchaseRecord | undefined,
): PurchaseRecord | undefined => {
if (!t) {
console.warn("purchase not found, not updating refund");
return;
}
if (t.refundsPending[pk]) {
t.refundsDone[pk] = t.refundsPending[pk];
delete t.refundsPending[pk];
}
return t;
};
const transformCoin = (
c: CoinRecord | undefined,
): CoinRecord | undefined => {
if (!c) {
console.warn("coin not found, can't apply refund");
return;
}
const refundAmount = Amounts.parseOrThrow(perm.refund_amount);
const refundFee = Amounts.parseOrThrow(perm.refund_fee);
c.status = CoinStatus.Dirty;
c.currentAmount = Amounts.add(c.currentAmount, refundAmount).amount;
c.currentAmount = Amounts.sub(c.currentAmount, refundFee).amount;
return c;
};
await runWithWriteTransaction(
ws.db,
[Stores.purchases, Stores.coins],
async tx => {
await tx.mutate(Stores.purchases, contractTermsHash, transformPurchase);
await tx.mutate(Stores.coins, perm.coin_pub, transformCoin);
},
);
refresh(ws, perm.coin_pub);
}
ws.badge.showNotification();
ws.notifier.notify();
}
export async function acceptRefundResponse(
ws: InternalWalletState,
refundResponse: MerchantRefundResponse,
): Promise<string> {
const refundPermissions = refundResponse.refund_permissions;
if (!refundPermissions.length) {
console.warn("got empty refund list");
throw Error("empty refund");
}
/**
* Add refund to purchase if not already added.
*/
function f(t: PurchaseRecord | undefined): PurchaseRecord | undefined {
if (!t) {
console.error("purchase not found, not adding refunds");
return;
}
t.timestamp_refund = getTimestampNow();
for (const perm of refundPermissions) {
if (
!t.refundsPending[perm.merchant_sig] &&
!t.refundsDone[perm.merchant_sig]
) {
t.refundsPending[perm.merchant_sig] = perm;
}
}
return t;
}
const hc = refundResponse.h_contract_terms;
// Add the refund permissions to the purchase within a DB transaction
await oneShotMutate(ws.db, Stores.purchases, hc, f);
ws.notifier.notify();
await submitRefunds(ws, hc);
return hc;
}
/**
* Accept a refund, return the contract hash for the contract
* that was involved in the refund.
*/
export async function applyRefund(
ws: InternalWalletState,
talerRefundUri: string,
): Promise<string> {
const parseResult = parseRefundUri(talerRefundUri);
if (!parseResult) {
throw Error("invalid refund URI");
}
const refundUrl = parseResult.refundUrl;
logger.trace("processing refund");
let resp;
try {
resp = await ws.http.get(refundUrl);
} catch (e) {
console.error("error downloading refund permission", e);
throw e;
}
const refundResponse = MerchantRefundResponse.checked(resp.responseJson);
return acceptRefundResponse(ws, refundResponse);
}

567
src/wallet-impl/reserves.ts Normal file
View File

@ -0,0 +1,567 @@
/*
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/>
*/
import {
CreateReserveRequest,
CreateReserveResponse,
getTimestampNow,
ConfirmReserveRequest,
OperationError,
} from "../walletTypes";
import { canonicalizeBaseUrl } from "../util/helpers";
import { InternalWalletState } from "./state";
import {
ReserveRecordStatus,
ReserveRecord,
CurrencyRecord,
Stores,
WithdrawalSessionRecord,
} from "../dbTypes";
import {
oneShotMutate,
oneShotPut,
oneShotGet,
runWithWriteTransaction,
TransactionAbort,
} from "../util/query";
import { Logger } from "../util/logging";
import * as Amounts from "../util/amounts";
import { updateExchangeFromUrl, getExchangeTrust } from "./exchanges";
import { WithdrawOperationStatusResponse, ReserveStatus } from "../talerTypes";
import { assertUnreachable } from "../util/assertUnreachable";
import { OperationFailedAndReportedError } from "../wallet";
import { encodeCrock } from "../crypto/talerCrypto";
import { randomBytes } from "../crypto/primitives/nacl-fast";
import {
getVerifiedWithdrawDenomList,
processWithdrawSession,
} from "./withdraw";
const logger = new Logger("reserves.ts");
/**
* Create a reserve, but do not flag it as confirmed yet.
*
* Adds the corresponding exchange as a trusted exchange if it is neither
* audited nor trusted already.
*/
export async function createReserve(
ws: InternalWalletState,
req: CreateReserveRequest,
): Promise<CreateReserveResponse> {
const keypair = await ws.cryptoApi.createEddsaKeypair();
const now = getTimestampNow();
const canonExchange = canonicalizeBaseUrl(req.exchange);
let reserveStatus;
if (req.bankWithdrawStatusUrl) {
reserveStatus = ReserveRecordStatus.REGISTERING_BANK;
} else {
reserveStatus = ReserveRecordStatus.UNCONFIRMED;
}
const currency = req.amount.currency;
const reserveRecord: ReserveRecord = {
created: now,
withdrawAllocatedAmount: Amounts.getZero(currency),
withdrawCompletedAmount: Amounts.getZero(currency),
withdrawRemainingAmount: Amounts.getZero(currency),
exchangeBaseUrl: canonExchange,
hasPayback: false,
initiallyRequestedAmount: req.amount,
reservePriv: keypair.priv,
reservePub: keypair.pub,
senderWire: req.senderWire,
timestampConfirmed: undefined,
timestampReserveInfoPosted: undefined,
bankWithdrawStatusUrl: req.bankWithdrawStatusUrl,
exchangeWire: req.exchangeWire,
reserveStatus,
lastStatusQuery: undefined,
};
const senderWire = req.senderWire;
if (senderWire) {
const rec = {
paytoUri: senderWire,
};
await oneShotPut(ws.db, Stores.senderWires, rec);
}
const exchangeInfo = await updateExchangeFromUrl(ws, req.exchange);
const exchangeDetails = exchangeInfo.details;
if (!exchangeDetails) {
throw Error("exchange not updated");
}
const { isAudited, isTrusted } = await getExchangeTrust(ws, exchangeInfo);
let currencyRecord = await oneShotGet(
ws.db,
Stores.currencies,
exchangeDetails.currency,
);
if (!currencyRecord) {
currencyRecord = {
auditors: [],
exchanges: [],
fractionalDigits: 2,
name: exchangeDetails.currency,
};
}
if (!isAudited && !isTrusted) {
currencyRecord.exchanges.push({
baseUrl: req.exchange,
exchangePub: exchangeDetails.masterPublicKey,
});
}
const cr: CurrencyRecord = currencyRecord;
const resp = await runWithWriteTransaction(
ws.db,
[Stores.currencies, Stores.reserves, Stores.bankWithdrawUris],
async tx => {
// Check if we have already created a reserve for that bankWithdrawStatusUrl
if (reserveRecord.bankWithdrawStatusUrl) {
const bwi = await tx.get(
Stores.bankWithdrawUris,
reserveRecord.bankWithdrawStatusUrl,
);
if (bwi) {
const otherReserve = await tx.get(Stores.reserves, bwi.reservePub);
if (otherReserve) {
logger.trace(
"returning existing reserve for bankWithdrawStatusUri",
);
return {
exchange: otherReserve.exchangeBaseUrl,
reservePub: otherReserve.reservePub,
};
}
}
await tx.put(Stores.bankWithdrawUris, {
reservePub: reserveRecord.reservePub,
talerWithdrawUri: reserveRecord.bankWithdrawStatusUrl,
});
}
await tx.put(Stores.currencies, cr);
await tx.put(Stores.reserves, reserveRecord);
const r: CreateReserveResponse = {
exchange: canonExchange,
reservePub: keypair.pub,
};
return r;
},
);
// Asynchronously process the reserve, but return
// to the caller already.
processReserve(ws, resp.reservePub).catch(e => {
console.error("Processing reserve failed:", e);
});
return resp;
}
/**
* First fetch information requred to withdraw from the reserve,
* then deplete the reserve, withdrawing coins until it is empty.
*
* The returned promise resolves once the reserve is set to the
* state DORMANT.
*/
export async function processReserve(
ws: InternalWalletState,
reservePub: string,
): Promise<void> {
const p = ws.memoProcessReserve.find(reservePub);
if (p) {
return p;
} else {
return ws.memoProcessReserve.put(
reservePub,
processReserveImpl(ws, reservePub),
);
}
}
async function registerReserveWithBank(
ws: InternalWalletState,
reservePub: string,
): Promise<void> {
let reserve = await oneShotGet(ws.db, Stores.reserves, reservePub);
switch (reserve?.reserveStatus) {
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
case ReserveRecordStatus.REGISTERING_BANK:
break;
default:
return;
}
const bankStatusUrl = reserve.bankWithdrawStatusUrl;
if (!bankStatusUrl) {
return;
}
console.log("making selection");
if (reserve.timestampReserveInfoPosted) {
throw Error("bank claims that reserve info selection is not done");
}
const bankResp = await ws.http.postJson(bankStatusUrl, {
reserve_pub: reservePub,
selected_exchange: reserve.exchangeWire,
});
console.log("got response", bankResp);
await oneShotMutate(ws.db, Stores.reserves, reservePub, r => {
switch (r.reserveStatus) {
case ReserveRecordStatus.REGISTERING_BANK:
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
break;
default:
return;
}
r.timestampReserveInfoPosted = getTimestampNow();
r.reserveStatus = ReserveRecordStatus.WAIT_CONFIRM_BANK;
return r;
});
return processReserveBankStatus(ws, reservePub);
}
export async function processReserveBankStatus(
ws: InternalWalletState,
reservePub: string,
): Promise<void> {
let reserve = await oneShotGet(ws.db, Stores.reserves, reservePub);
switch (reserve?.reserveStatus) {
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
case ReserveRecordStatus.REGISTERING_BANK:
break;
default:
return;
}
const bankStatusUrl = reserve.bankWithdrawStatusUrl;
if (!bankStatusUrl) {
return;
}
let status: WithdrawOperationStatusResponse;
try {
const statusResp = await ws.http.get(bankStatusUrl);
status = WithdrawOperationStatusResponse.checked(statusResp.responseJson);
} catch (e) {
throw e;
}
if (status.selection_done) {
if (reserve.reserveStatus === ReserveRecordStatus.REGISTERING_BANK) {
await registerReserveWithBank(ws, reservePub);
return await processReserveBankStatus(ws, reservePub);
}
} else {
await registerReserveWithBank(ws, reservePub);
return await processReserveBankStatus(ws, reservePub);
}
if (status.transfer_done) {
await oneShotMutate(ws.db, Stores.reserves, reservePub, r => {
switch (r.reserveStatus) {
case ReserveRecordStatus.REGISTERING_BANK:
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
break;
default:
return;
}
const now = getTimestampNow();
r.timestampConfirmed = now;
r.reserveStatus = ReserveRecordStatus.QUERYING_STATUS;
return r;
});
await processReserveImpl(ws, reservePub);
} else {
await oneShotMutate(ws.db, Stores.reserves, reservePub, r => {
switch (r.reserveStatus) {
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
break;
default:
return;
}
r.bankWithdrawConfirmUrl = status.confirm_transfer_url;
return r;
});
}
}
async function setReserveError(
ws: InternalWalletState,
reservePub: string,
err: OperationError,
): Promise<void> {
const mut = (reserve: ReserveRecord) => {
reserve.lastError = err;
return reserve;
};
await oneShotMutate(ws.db, Stores.reserves, reservePub, mut);
}
/**
* Update the information about a reserve that is stored in the wallet
* by quering the reserve's exchange.
*/
async function updateReserve(
ws: InternalWalletState,
reservePub: string,
): Promise<void> {
const reserve = await oneShotGet(ws.db, Stores.reserves, reservePub);
if (!reserve) {
throw Error("reserve not in db");
}
if (reserve.timestampConfirmed === undefined) {
throw Error("reserve not confirmed yet");
}
if (reserve.reserveStatus !== ReserveRecordStatus.QUERYING_STATUS) {
return;
}
const reqUrl = new URL("reserve/status", reserve.exchangeBaseUrl);
reqUrl.searchParams.set("reserve_pub", reservePub);
let resp;
try {
resp = await ws.http.get(reqUrl.href);
} catch (e) {
if (e.response?.status === 404) {
return;
} else {
const m = e.message;
setReserveError(ws, reservePub, {
type: "network",
details: {},
message: m,
});
throw new OperationFailedAndReportedError(m);
}
}
const reserveInfo = ReserveStatus.checked(resp.responseJson);
const balance = Amounts.parseOrThrow(reserveInfo.balance);
await oneShotMutate(ws.db, Stores.reserves, reserve.reservePub, r => {
if (r.reserveStatus !== ReserveRecordStatus.QUERYING_STATUS) {
return;
}
// FIXME: check / compare history!
if (!r.lastStatusQuery) {
// FIXME: check if this matches initial expectations
r.withdrawRemainingAmount = balance;
} else {
const expectedBalance = Amounts.sub(
r.withdrawAllocatedAmount,
r.withdrawCompletedAmount,
);
const cmp = Amounts.cmp(balance, expectedBalance.amount);
if (cmp == 0) {
// Nothing changed.
return;
}
if (cmp > 0) {
const extra = Amounts.sub(balance, expectedBalance.amount).amount;
r.withdrawRemainingAmount = Amounts.add(
r.withdrawRemainingAmount,
extra,
).amount;
} else {
// We're missing some money.
}
}
r.lastStatusQuery = getTimestampNow();
r.reserveStatus = ReserveRecordStatus.WITHDRAWING;
return r;
});
ws.notifier.notify();
}
async function processReserveImpl(
ws: InternalWalletState,
reservePub: string,
): Promise<void> {
const reserve = await oneShotGet(ws.db, Stores.reserves, reservePub);
if (!reserve) {
console.log("not processing reserve: reserve does not exist");
return;
}
logger.trace(
`Processing reserve ${reservePub} with status ${reserve.reserveStatus}`,
);
switch (reserve.reserveStatus) {
case ReserveRecordStatus.UNCONFIRMED:
// nothing to do
break;
case ReserveRecordStatus.REGISTERING_BANK:
await processReserveBankStatus(ws, reservePub);
return processReserveImpl(ws, reservePub);
case ReserveRecordStatus.QUERYING_STATUS:
await updateReserve(ws, reservePub);
return processReserveImpl(ws, reservePub);
case ReserveRecordStatus.WITHDRAWING:
await depleteReserve(ws, reservePub);
break;
case ReserveRecordStatus.DORMANT:
// nothing to do
break;
case ReserveRecordStatus.WAIT_CONFIRM_BANK:
await processReserveBankStatus(ws, reservePub);
break;
default:
console.warn("unknown reserve record status:", reserve.reserveStatus);
assertUnreachable(reserve.reserveStatus);
break;
}
}
export async function confirmReserve(
ws: InternalWalletState,
req: ConfirmReserveRequest,
): Promise<void> {
const now = getTimestampNow();
await oneShotMutate(ws.db, Stores.reserves, req.reservePub, reserve => {
if (reserve.reserveStatus !== ReserveRecordStatus.UNCONFIRMED) {
return;
}
reserve.timestampConfirmed = now;
reserve.reserveStatus = ReserveRecordStatus.QUERYING_STATUS;
return reserve;
});
ws.notifier.notify();
processReserve(ws, req.reservePub).catch(e => {
console.log("processing reserve failed:", e);
});
}
/**
* Withdraw coins from a reserve until it is empty.
*
* When finished, marks the reserve as depleted by setting
* the depleted timestamp.
*/
async function depleteReserve(
ws: InternalWalletState,
reservePub: string,
): Promise<void> {
const reserve = await oneShotGet(ws.db, Stores.reserves, reservePub);
if (!reserve) {
return;
}
if (reserve.reserveStatus !== ReserveRecordStatus.WITHDRAWING) {
return;
}
logger.trace(`depleting reserve ${reservePub}`);
const withdrawAmount = reserve.withdrawRemainingAmount;
logger.trace(`getting denom list`);
const denomsForWithdraw = await getVerifiedWithdrawDenomList(
ws,
reserve.exchangeBaseUrl,
withdrawAmount,
);
logger.trace(`got denom list`);
if (denomsForWithdraw.length === 0) {
const m = `Unable to withdraw from reserve, no denominations are available to withdraw.`;
await setReserveError(ws, reserve.reservePub, {
type: "internal",
message: m,
details: {},
});
console.log(m);
throw new OperationFailedAndReportedError(m);
}
logger.trace("selected denominations");
const withdrawalSessionId = encodeCrock(randomBytes(32));
const withdrawalRecord: WithdrawalSessionRecord = {
withdrawSessionId: withdrawalSessionId,
exchangeBaseUrl: reserve.exchangeBaseUrl,
source: {
type: "reserve",
reservePub: reserve.reservePub,
},
withdrawalAmount: Amounts.toString(withdrawAmount),
startTimestamp: getTimestampNow(),
denoms: denomsForWithdraw.map(x => x.denomPub),
withdrawn: denomsForWithdraw.map(x => false),
planchets: denomsForWithdraw.map(x => undefined),
};
const totalCoinValue = Amounts.sum(denomsForWithdraw.map(x => x.value))
.amount;
const totalCoinWithdrawFee = Amounts.sum(
denomsForWithdraw.map(x => x.feeWithdraw),
).amount;
const totalWithdrawAmount = Amounts.add(totalCoinValue, totalCoinWithdrawFee)
.amount;
function mutateReserve(r: ReserveRecord): ReserveRecord {
const remaining = Amounts.sub(
r.withdrawRemainingAmount,
totalWithdrawAmount,
);
if (remaining.saturated) {
console.error("can't create planchets, saturated");
throw TransactionAbort;
}
const allocated = Amounts.add(
r.withdrawAllocatedAmount,
totalWithdrawAmount,
);
if (allocated.saturated) {
console.error("can't create planchets, saturated");
throw TransactionAbort;
}
r.withdrawRemainingAmount = remaining.amount;
r.withdrawAllocatedAmount = allocated.amount;
r.reserveStatus = ReserveRecordStatus.DORMANT;
return r;
}
const success = await runWithWriteTransaction(
ws.db,
[Stores.withdrawalSession, Stores.reserves],
async tx => {
const myReserve = await tx.get(Stores.reserves, reservePub);
if (!myReserve) {
return false;
}
if (myReserve.reserveStatus !== ReserveRecordStatus.WITHDRAWING) {
return false;
}
await tx.mutate(Stores.reserves, reserve.reservePub, mutateReserve);
await tx.put(Stores.withdrawalSession, withdrawalRecord);
return true;
},
);
if (success) {
console.log("processing new withdraw session");
await processWithdrawSession(ws, withdrawalSessionId);
} else {
console.trace("withdraw session already existed");
}
}

274
src/wallet-impl/return.ts Normal file
View File

@ -0,0 +1,274 @@
/*
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/>
*/
/**
* Imports.
*/
import {
HistoryQuery,
HistoryEvent,
WalletBalance,
WalletBalanceEntry,
ReturnCoinsRequest,
CoinWithDenom,
} from "../walletTypes";
import { oneShotIter, runWithWriteTransaction, oneShotGet, oneShotIterIndex, oneShotPut } from "../util/query";
import { InternalWalletState } from "./state";
import { Stores, TipRecord, CoinStatus, CoinsReturnRecord, CoinRecord } from "../dbTypes";
import * as Amounts from "../util/amounts";
import { AmountJson } from "../util/amounts";
import { Logger } from "../util/logging";
import { canonicalJson } from "../util/helpers";
import { ContractTerms } from "../talerTypes";
import { selectPayCoins } from "./pay";
const logger = new Logger("return.ts");
async function getCoinsForReturn(
ws: InternalWalletState,
exchangeBaseUrl: string,
amount: AmountJson,
): Promise<CoinWithDenom[] | undefined> {
const exchange = await oneShotGet(
ws.db,
Stores.exchanges,
exchangeBaseUrl,
);
if (!exchange) {
throw Error(`Exchange ${exchangeBaseUrl} not known to the wallet`);
}
const coins: CoinRecord[] = await oneShotIterIndex(
ws.db,
Stores.coins.exchangeBaseUrlIndex,
exchange.baseUrl,
).toArray();
if (!coins || !coins.length) {
return [];
}
const denoms = await oneShotIterIndex(
ws.db,
Stores.denominations.exchangeBaseUrlIndex,
exchange.baseUrl,
).toArray();
// Denomination of the first coin, we assume that all other
// coins have the same currency
const firstDenom = await oneShotGet(ws.db, Stores.denominations, [
exchange.baseUrl,
coins[0].denomPub,
]);
if (!firstDenom) {
throw Error("db inconsistent");
}
const currency = firstDenom.value.currency;
const cds: CoinWithDenom[] = [];
for (const coin of coins) {
const denom = await oneShotGet(ws.db, Stores.denominations, [
exchange.baseUrl,
coin.denomPub,
]);
if (!denom) {
throw Error("db inconsistent");
}
if (denom.value.currency !== currency) {
console.warn(
`same pubkey for different currencies at exchange ${exchange.baseUrl}`,
);
continue;
}
if (coin.suspended) {
continue;
}
if (coin.status !== CoinStatus.Fresh) {
continue;
}
cds.push({ coin, denom });
}
const res = selectPayCoins(denoms, cds, amount, amount);
if (res) {
return res.cds;
}
return undefined;
}
/**
* Trigger paying coins back into the user's account.
*/
export async function returnCoins(
ws: InternalWalletState,
req: ReturnCoinsRequest,
): Promise<void> {
logger.trace("got returnCoins request", req);
const wireType = (req.senderWire as any).type;
logger.trace("wireType", wireType);
if (!wireType || typeof wireType !== "string") {
console.error(`wire type must be a non-empty string, not ${wireType}`);
return;
}
const stampSecNow = Math.floor(new Date().getTime() / 1000);
const exchange = await oneShotGet(ws.db, Stores.exchanges, req.exchange);
if (!exchange) {
console.error(`Exchange ${req.exchange} not known to the wallet`);
return;
}
const exchangeDetails = exchange.details;
if (!exchangeDetails) {
throw Error("exchange information needs to be updated first.");
}
logger.trace("selecting coins for return:", req);
const cds = await getCoinsForReturn(ws, req.exchange, req.amount);
logger.trace(cds);
if (!cds) {
throw Error("coin return impossible, can't select coins");
}
const { priv, pub } = await ws.cryptoApi.createEddsaKeypair();
const wireHash = await ws.cryptoApi.hashString(
canonicalJson(req.senderWire),
);
const contractTerms: ContractTerms = {
H_wire: wireHash,
amount: Amounts.toString(req.amount),
auditors: [],
exchanges: [
{ master_pub: exchangeDetails.masterPublicKey, url: exchange.baseUrl },
],
extra: {},
fulfillment_url: "",
locations: [],
max_fee: Amounts.toString(req.amount),
merchant: {},
merchant_pub: pub,
order_id: "none",
pay_deadline: `/Date(${stampSecNow + 30 * 5})/`,
wire_transfer_deadline: `/Date(${stampSecNow + 60 * 5})/`,
merchant_base_url: "taler://return-to-account",
products: [],
refund_deadline: `/Date(${stampSecNow + 60 * 5})/`,
timestamp: `/Date(${stampSecNow})/`,
wire_method: wireType,
};
const contractTermsHash = await ws.cryptoApi.hashString(
canonicalJson(contractTerms),
);
const payCoinInfo = await ws.cryptoApi.signDeposit(
contractTerms,
cds,
Amounts.parseOrThrow(contractTerms.amount),
);
logger.trace("pci", payCoinInfo);
const coins = payCoinInfo.sigs.map(s => ({ coinPaySig: s }));
const coinsReturnRecord: CoinsReturnRecord = {
coins,
contractTerms,
contractTermsHash,
exchange: exchange.baseUrl,
merchantPriv: priv,
wire: req.senderWire,
};
await runWithWriteTransaction(
ws.db,
[Stores.coinsReturns, Stores.coins],
async tx => {
await tx.put(Stores.coinsReturns, coinsReturnRecord);
for (let c of payCoinInfo.updatedCoins) {
await tx.put(Stores.coins, c);
}
},
);
ws.badge.showNotification();
ws.notifier.notify();
depositReturnedCoins(ws, coinsReturnRecord);
}
async function depositReturnedCoins(
ws: InternalWalletState,
coinsReturnRecord: CoinsReturnRecord,
): Promise<void> {
for (const c of coinsReturnRecord.coins) {
if (c.depositedSig) {
continue;
}
const req = {
H_wire: coinsReturnRecord.contractTerms.H_wire,
coin_pub: c.coinPaySig.coin_pub,
coin_sig: c.coinPaySig.coin_sig,
contribution: c.coinPaySig.contribution,
denom_pub: c.coinPaySig.denom_pub,
h_contract_terms: coinsReturnRecord.contractTermsHash,
merchant_pub: coinsReturnRecord.contractTerms.merchant_pub,
pay_deadline: coinsReturnRecord.contractTerms.pay_deadline,
refund_deadline: coinsReturnRecord.contractTerms.refund_deadline,
timestamp: coinsReturnRecord.contractTerms.timestamp,
ub_sig: c.coinPaySig.ub_sig,
wire: coinsReturnRecord.wire,
wire_transfer_deadline: coinsReturnRecord.contractTerms.pay_deadline,
};
logger.trace("req", req);
const reqUrl = new URL("deposit", coinsReturnRecord.exchange);
const resp = await ws.http.postJson(reqUrl.href, req);
if (resp.status !== 200) {
console.error("deposit failed due to status code", resp);
continue;
}
const respJson = resp.responseJson;
if (respJson.status !== "DEPOSIT_OK") {
console.error("deposit failed", resp);
continue;
}
if (!respJson.sig) {
console.error("invalid 'sig' field", resp);
continue;
}
// FIXME: verify signature
// For every successful deposit, we replace the old record with an updated one
const currentCrr = await oneShotGet(
ws.db,
Stores.coinsReturns,
coinsReturnRecord.contractTermsHash,
);
if (!currentCrr) {
console.error("database inconsistent");
continue;
}
for (const nc of currentCrr.coins) {
if (nc.coinPaySig.coin_pub === c.coinPaySig.coin_pub) {
nc.depositedSig = respJson.sig;
}
}
await oneShotPut(ws.db, Stores.coinsReturns, currentCrr);
ws.notifier.notify();
}
}

32
src/wallet-impl/state.ts Normal file
View File

@ -0,0 +1,32 @@
/*
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/>
*/
import { HttpRequestLibrary } from "../util/http";
import { Badge, Notifier, NextUrlResult } from "../walletTypes";
import { SpeculativePayData } from "./pay";
import { CryptoApi } from "../crypto/cryptoApi";
import { AsyncOpMemo } from "../util/asyncMemo";
export interface InternalWalletState {
db: IDBDatabase;
http: HttpRequestLibrary;
badge: Badge;
notifier: Notifier;
cryptoApi: CryptoApi;
speculativePayData: SpeculativePayData | undefined;
cachedNextUrl: { [fulfillmentUrl: string]: NextUrlResult };
memoProcessReserve: AsyncOpMemo<void>;
}

246
src/wallet-impl/tip.ts Normal file
View File

@ -0,0 +1,246 @@
/*
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/>
*/
import { oneShotGet, oneShotPut, oneShotMutate, runWithWriteTransaction } from "../util/query";
import { InternalWalletState } from "./state";
import { parseTipUri } from "../util/taleruri";
import { TipStatus, getTimestampNow } from "../walletTypes";
import { TipPickupGetResponse, TipPlanchetDetail, TipResponse } from "../talerTypes";
import * as Amounts from "../util/amounts";
import { Stores, PlanchetRecord, WithdrawalSessionRecord } from "../dbTypes";
import { getWithdrawDetailsForAmount, getVerifiedWithdrawDenomList, processWithdrawSession } from "./withdraw";
import { getTalerStampSec } from "../util/helpers";
import { updateExchangeFromUrl } from "./exchanges";
import { getRandomBytes, encodeCrock } from "../crypto/talerCrypto";
export async function getTipStatus(
ws: InternalWalletState,
talerTipUri: string): Promise<TipStatus> {
const res = parseTipUri(talerTipUri);
if (!res) {
throw Error("invalid taler://tip URI");
}
const tipStatusUrl = new URL("tip-pickup", res.merchantBaseUrl);
tipStatusUrl.searchParams.set("tip_id", res.merchantTipId);
console.log("checking tip status from", tipStatusUrl.href);
const merchantResp = await ws.http.get(tipStatusUrl.href);
console.log("resp:", merchantResp.responseJson);
const tipPickupStatus = TipPickupGetResponse.checked(
merchantResp.responseJson,
);
console.log("status", tipPickupStatus);
let amount = Amounts.parseOrThrow(tipPickupStatus.amount);
let tipRecord = await oneShotGet(ws.db, Stores.tips, [
res.merchantTipId,
res.merchantOrigin,
]);
if (!tipRecord) {
const withdrawDetails = await getWithdrawDetailsForAmount(
ws,
tipPickupStatus.exchange_url,
amount,
);
const tipId = encodeCrock(getRandomBytes(32));
tipRecord = {
tipId,
accepted: false,
amount,
deadline: getTalerStampSec(tipPickupStatus.stamp_expire)!,
exchangeUrl: tipPickupStatus.exchange_url,
merchantBaseUrl: res.merchantBaseUrl,
nextUrl: undefined,
pickedUp: false,
planchets: undefined,
response: undefined,
timestamp: getTimestampNow(),
merchantTipId: res.merchantTipId,
totalFees: Amounts.add(
withdrawDetails.overhead,
withdrawDetails.withdrawFee,
).amount,
};
await oneShotPut(ws.db, Stores.tips, tipRecord);
}
const tipStatus: TipStatus = {
accepted: !!tipRecord && tipRecord.accepted,
amount: Amounts.parseOrThrow(tipPickupStatus.amount),
amountLeft: Amounts.parseOrThrow(tipPickupStatus.amount_left),
exchangeUrl: tipPickupStatus.exchange_url,
nextUrl: tipPickupStatus.extra.next_url,
merchantOrigin: res.merchantOrigin,
merchantTipId: res.merchantTipId,
expirationTimestamp: getTalerStampSec(tipPickupStatus.stamp_expire)!,
timestamp: getTalerStampSec(tipPickupStatus.stamp_created)!,
totalFees: tipRecord.totalFees,
tipId: tipRecord.tipId,
};
return tipStatus;
}
export async function processTip(
ws: InternalWalletState,
tipId: string,
) {
let tipRecord = await oneShotGet(ws.db, Stores.tips, tipId);
if (!tipRecord) {
return;
}
if (tipRecord.pickedUp) {
console.log("tip already picked up");
return;
}
if (!tipRecord.planchets) {
await updateExchangeFromUrl(ws, tipRecord.exchangeUrl);
const denomsForWithdraw = await getVerifiedWithdrawDenomList(
ws,
tipRecord.exchangeUrl,
tipRecord.amount,
);
const planchets = await Promise.all(
denomsForWithdraw.map(d => ws.cryptoApi.createTipPlanchet(d)),
);
await oneShotMutate(ws.db, Stores.tips, tipId, r => {
if (!r.planchets) {
r.planchets = planchets;
}
return r;
});
}
tipRecord = await oneShotGet(ws.db, Stores.tips, tipId);
if (!tipRecord) {
throw Error("tip not in database");
}
if (!tipRecord.planchets) {
throw Error("invariant violated");
}
console.log("got planchets for tip!");
// Planchets in the form that the merchant expects
const planchetsDetail: TipPlanchetDetail[] = tipRecord.planchets.map(p => ({
coin_ev: p.coinEv,
denom_pub_hash: p.denomPubHash,
}));
let merchantResp;
const tipStatusUrl = new URL("tip-pickup", tipRecord.merchantBaseUrl);
try {
const req = { planchets: planchetsDetail, tip_id: tipRecord.merchantTipId };
merchantResp = await ws.http.postJson(tipStatusUrl.href, req);
console.log("got merchant resp:", merchantResp);
} catch (e) {
console.log("tipping failed", e);
throw e;
}
const response = TipResponse.checked(merchantResp.responseJson);
if (response.reserve_sigs.length !== tipRecord.planchets.length) {
throw Error("number of tip responses does not match requested planchets");
}
const planchets: PlanchetRecord[] = [];
for (let i = 0; i < tipRecord.planchets.length; i++) {
const tipPlanchet = tipRecord.planchets[i];
const planchet: PlanchetRecord = {
blindingKey: tipPlanchet.blindingKey,
coinEv: tipPlanchet.coinEv,
coinPriv: tipPlanchet.coinPriv,
coinPub: tipPlanchet.coinPub,
coinValue: tipPlanchet.coinValue,
denomPub: tipPlanchet.denomPub,
denomPubHash: tipPlanchet.denomPubHash,
reservePub: response.reserve_pub,
withdrawSig: response.reserve_sigs[i].reserve_sig,
isFromTip: true,
};
planchets.push(planchet);
}
const withdrawalSessionId = encodeCrock(getRandomBytes(32));
const withdrawalSession: WithdrawalSessionRecord = {
denoms: planchets.map((x) => x.denomPub),
exchangeBaseUrl: tipRecord.exchangeUrl,
planchets: planchets,
source: {
type: "tip",
tipId: tipRecord.tipId,
},
startTimestamp: getTimestampNow(),
withdrawSessionId: withdrawalSessionId,
withdrawalAmount: Amounts.toString(tipRecord.amount),
withdrawn: planchets.map((x) => false),
};
await runWithWriteTransaction(ws.db, [Stores.tips, Stores.withdrawalSession], async (tx) => {
const tr = await tx.get(Stores.tips, tipId);
if (!tr) {
return;
}
if (tr.pickedUp) {
return;
}
tr.pickedUp = true;
await tx.put(Stores.tips, tr);
await tx.put(Stores.withdrawalSession, withdrawalSession);
});
await processWithdrawSession(ws, withdrawalSessionId);
ws.notifier.notify();
ws.badge.showNotification();
return;
}
export async function acceptTip(
ws: InternalWalletState,
tipId: string,
): Promise<void> {
const tipRecord = await oneShotGet(ws.db, Stores.tips, tipId);
if (!tipRecord) {
console.log("tip not found");
return;
}
tipRecord.accepted = true;
await oneShotPut(ws.db, Stores.tips, tipRecord);
await processTip(ws, tipId);
return;
}

577
src/wallet-impl/withdraw.ts Normal file
View File

@ -0,0 +1,577 @@
/*
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/>
*/
import { AmountJson } from "../util/amounts";
import {
DenominationRecord,
Stores,
DenominationStatus,
CoinStatus,
CoinRecord,
PlanchetRecord,
} from "../dbTypes";
import * as Amounts from "../util/amounts";
import {
getTimestampNow,
AcceptWithdrawalResponse,
DownloadedWithdrawInfo,
ReserveCreationInfo,
WithdrawDetails,
} from "../walletTypes";
import { WithdrawOperationStatusResponse } from "../talerTypes";
import { InternalWalletState } from "./state";
import { parseWithdrawUri } from "../util/taleruri";
import { Logger } from "../util/logging";
import {
oneShotGet,
oneShotPut,
oneShotIterIndex,
oneShotGetIndexed,
runWithWriteTransaction,
} from "../util/query";
import {
updateExchangeFromUrl,
getExchangePaytoUri,
getExchangeTrust,
} from "./exchanges";
import { createReserve, processReserveBankStatus } from "./reserves";
import { WALLET_PROTOCOL_VERSION } from "../wallet";
import * as LibtoolVersion from "../util/libtoolVersion";
const logger = new Logger("withdraw.ts");
function isWithdrawableDenom(d: DenominationRecord) {
const now = getTimestampNow();
const started = now.t_ms >= d.stampStart.t_ms;
const stillOkay = d.stampExpireWithdraw.t_ms + 60 * 1000 > now.t_ms;
return started && stillOkay;
}
/**
* Get a list of denominations (with repetitions possible)
* whose total value is as close as possible to the available
* amount, but never larger.
*/
export function getWithdrawDenomList(
amountAvailable: AmountJson,
denoms: DenominationRecord[],
): DenominationRecord[] {
let remaining = Amounts.copy(amountAvailable);
const ds: DenominationRecord[] = [];
denoms = denoms.filter(isWithdrawableDenom);
denoms.sort((d1, d2) => Amounts.cmp(d2.value, d1.value));
// This is an arbitrary number of coins
// we can withdraw in one go. It's not clear if this limit
// is useful ...
for (let i = 0; i < 1000; i++) {
let found = false;
for (const d of denoms) {
const cost = Amounts.add(d.value, d.feeWithdraw).amount;
if (Amounts.cmp(remaining, cost) < 0) {
continue;
}
found = true;
remaining = Amounts.sub(remaining, cost).amount;
ds.push(d);
break;
}
if (!found) {
break;
}
}
return ds;
}
/**
* Get information about a withdrawal from
* a taler://withdraw URI.
*/
export async function getWithdrawalInfo(
ws: InternalWalletState,
talerWithdrawUri: string,
): Promise<DownloadedWithdrawInfo> {
const uriResult = parseWithdrawUri(talerWithdrawUri);
if (!uriResult) {
throw Error("can't parse URL");
}
const resp = await ws.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,
};
}
export async function acceptWithdrawal(
ws: InternalWalletState,
talerWithdrawUri: string,
selectedExchange: string,
): Promise<AcceptWithdrawalResponse> {
const withdrawInfo = await getWithdrawalInfo(ws, talerWithdrawUri);
const exchangeWire = await getExchangePaytoUri(
ws,
selectedExchange,
withdrawInfo.wireTypes,
);
const reserve = await createReserve(ws, {
amount: withdrawInfo.amount,
bankWithdrawStatusUrl: withdrawInfo.extractedStatusUrl,
exchange: selectedExchange,
senderWire: withdrawInfo.senderWire,
exchangeWire: exchangeWire,
});
// We do this here, as the reserve should be registered before we return,
// so that we can redirect the user to the bank's status page.
await processReserveBankStatus(ws, reserve.reservePub);
console.log("acceptWithdrawal: returning");
return {
reservePub: reserve.reservePub,
confirmTransferUrl: withdrawInfo.confirmTransferUrl,
};
}
async function getPossibleDenoms(
ws: InternalWalletState,
exchangeBaseUrl: string,
): Promise<DenominationRecord[]> {
return await oneShotIterIndex(
ws.db,
Stores.denominations.exchangeBaseUrlIndex,
exchangeBaseUrl,
).filter(d => {
return (
d.status === DenominationStatus.Unverified ||
d.status === DenominationStatus.VerifiedGood
);
});
}
/**
* Given a planchet, withdraw a coin from the exchange.
*/
async function processPlanchet(
ws: InternalWalletState,
withdrawalSessionId: string,
coinIdx: number,
): Promise<void> {
const withdrawalSession = await oneShotGet(
ws.db,
Stores.withdrawalSession,
withdrawalSessionId,
);
if (!withdrawalSession) {
return;
}
if (withdrawalSession.withdrawn[coinIdx]) {
return;
}
if (withdrawalSession.source.type === "reserve") {
}
const planchet = withdrawalSession.planchets[coinIdx];
if (!planchet) {
console.log("processPlanchet: planchet not found");
return;
}
const exchange = await oneShotGet(
ws.db,
Stores.exchanges,
withdrawalSession.exchangeBaseUrl,
);
if (!exchange) {
console.error("db inconsistent: exchange for planchet not found");
return;
}
const denom = await oneShotGet(ws.db, Stores.denominations, [
withdrawalSession.exchangeBaseUrl,
planchet.denomPub,
]);
if (!denom) {
console.error("db inconsistent: denom for planchet not found");
return;
}
const wd: any = {};
wd.denom_pub_hash = planchet.denomPubHash;
wd.reserve_pub = planchet.reservePub;
wd.reserve_sig = planchet.withdrawSig;
wd.coin_ev = planchet.coinEv;
const reqUrl = new URL("reserve/withdraw", exchange.baseUrl).href;
const resp = await ws.http.postJson(reqUrl, wd);
const r = resp.responseJson;
const denomSig = await ws.cryptoApi.rsaUnblind(
r.ev_sig,
planchet.blindingKey,
planchet.denomPub,
);
const coin: CoinRecord = {
blindingKey: planchet.blindingKey,
coinPriv: planchet.coinPriv,
coinPub: planchet.coinPub,
currentAmount: planchet.coinValue,
denomPub: planchet.denomPub,
denomPubHash: planchet.denomPubHash,
denomSig,
exchangeBaseUrl: withdrawalSession.exchangeBaseUrl,
reservePub: planchet.reservePub,
status: CoinStatus.Fresh,
coinIndex: coinIdx,
withdrawSessionId: withdrawalSessionId,
};
await runWithWriteTransaction(
ws.db,
[Stores.coins, Stores.withdrawalSession, Stores.reserves],
async tx => {
const ws = await tx.get(
Stores.withdrawalSession,
withdrawalSessionId,
);
if (!ws) {
return;
}
if (ws.withdrawn[coinIdx]) {
// Already withdrawn
return;
}
ws.withdrawn[coinIdx] = true;
await tx.put(Stores.withdrawalSession, ws);
if (!planchet.isFromTip) {
const r = await tx.get(Stores.reserves, planchet.reservePub);
if (r) {
r.withdrawCompletedAmount = Amounts.add(
r.withdrawCompletedAmount,
Amounts.add(denom.value, denom.feeWithdraw).amount,
).amount;
await tx.put(Stores.reserves, r);
}
}
await tx.add(Stores.coins, coin);
},
);
ws.notifier.notify();
logger.trace(`withdraw of one coin ${coin.coinPub} finished`);
}
/**
* 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.
*/
export async function getVerifiedWithdrawDenomList(
ws: InternalWalletState,
exchangeBaseUrl: string,
amount: AmountJson,
): Promise<DenominationRecord[]> {
const exchange = await oneShotGet(ws.db, Stores.exchanges, exchangeBaseUrl);
if (!exchange) {
console.log("exchange not found");
throw Error(`exchange ${exchangeBaseUrl} not found`);
}
const exchangeDetails = exchange.details;
if (!exchangeDetails) {
console.log("exchange details not available");
throw Error(`exchange ${exchangeBaseUrl} details not available`);
}
console.log("getting possible denoms");
const possibleDenoms = await getPossibleDenoms(ws, exchange.baseUrl);
console.log("got possible denoms");
let allValid = false;
let selectedDenoms: DenominationRecord[];
do {
allValid = true;
const nextPossibleDenoms = [];
selectedDenoms = getWithdrawDenomList(amount, possibleDenoms);
console.log("got withdraw denom list");
for (const denom of selectedDenoms || []) {
if (denom.status === DenominationStatus.Unverified) {
console.log(
"checking validity",
denom,
exchangeDetails.masterPublicKey,
);
const valid = await ws.cryptoApi.isValidDenom(
denom,
exchangeDetails.masterPublicKey,
);
console.log("done checking validity");
if (!valid) {
denom.status = DenominationStatus.VerifiedBad;
allValid = false;
} else {
denom.status = DenominationStatus.VerifiedGood;
nextPossibleDenoms.push(denom);
}
await oneShotPut(ws.db, Stores.denominations, denom);
} else {
nextPossibleDenoms.push(denom);
}
}
} while (selectedDenoms.length > 0 && !allValid);
console.log("returning denoms");
return selectedDenoms;
}
async function processWithdrawCoin(
ws: InternalWalletState,
withdrawalSessionId: string,
coinIndex: number,
) {
logger.info("starting withdraw for coin");
const withdrawalSession = await oneShotGet(
ws.db,
Stores.withdrawalSession,
withdrawalSessionId,
);
if (!withdrawalSession) {
console.log("ws doesn't exist");
return;
}
const coin = await oneShotGetIndexed(
ws.db,
Stores.coins.byWithdrawalWithIdx,
[withdrawalSessionId, coinIndex],
);
if (coin) {
console.log("coin already exists");
return;
}
if (withdrawalSession.planchets[coinIndex]) {
return processPlanchet(ws, withdrawalSessionId, coinIndex);
} else {
const src = withdrawalSession.source;
if (src.type !== "reserve") {
throw Error("invalid state");
}
const reserve = await oneShotGet(ws.db, Stores.reserves, src.reservePub)
if (!reserve) {
return;
}
const denom = await oneShotGet(ws.db, Stores.denominations, [
withdrawalSession.exchangeBaseUrl,
withdrawalSession.denoms[coinIndex],
]);
if (!denom) {
return;
}
const r = await ws.cryptoApi.createPlanchet({
denomPub: denom.denomPub,
feeWithdraw: denom.feeWithdraw,
reservePriv: reserve.reservePriv,
reservePub: reserve.reservePub,
value: denom.value,
});
const newPlanchet: PlanchetRecord = {
blindingKey: r.blindingKey,
coinEv: r.coinEv,
coinPriv: r.coinPriv,
coinPub: r.coinPub,
coinValue: r.coinValue,
denomPub: r.denomPub,
denomPubHash: r.denomPubHash,
isFromTip: false,
reservePub: r.reservePub,
withdrawSig: r.withdrawSig,
};
await runWithWriteTransaction(
ws.db,
[Stores.withdrawalSession],
async tx => {
const myWs = await tx.get(
Stores.withdrawalSession,
withdrawalSessionId,
);
if (!myWs) {
return;
}
if (myWs.planchets[coinIndex]) {
return;
}
myWs.planchets[coinIndex] = newPlanchet;
await tx.put(Stores.withdrawalSession, myWs);
},
);
await processPlanchet(ws, withdrawalSessionId, coinIndex);
}
}
export async function processWithdrawSession(
ws: InternalWalletState,
withdrawalSessionId: string,
): Promise<void> {
logger.trace("processing withdraw session", withdrawalSessionId);
const withdrawalSession = await oneShotGet(
ws.db,
Stores.withdrawalSession,
withdrawalSessionId,
);
if (!withdrawalSession) {
logger.trace("withdraw session doesn't exist");
return;
}
const ps = withdrawalSession.denoms.map((d, i) =>
processWithdrawCoin(ws, withdrawalSessionId, i),
);
await Promise.all(ps);
ws.badge.showNotification();
return;
}
export async function getWithdrawDetailsForAmount(
ws: InternalWalletState,
baseUrl: string,
amount: AmountJson,
): Promise<ReserveCreationInfo> {
const exchangeInfo = await updateExchangeFromUrl(ws, baseUrl);
const exchangeDetails = exchangeInfo.details;
if (!exchangeDetails) {
throw Error(`exchange ${exchangeInfo.baseUrl} details not available`);
}
const exchangeWireInfo = exchangeInfo.wireInfo;
if (!exchangeWireInfo) {
throw Error(`exchange ${exchangeInfo.baseUrl} wire details not available`);
}
const selectedDenoms = await getVerifiedWithdrawDenomList(
ws,
baseUrl,
amount,
);
let acc = Amounts.getZero(amount.currency);
for (const d of selectedDenoms) {
acc = Amounts.add(acc, d.feeWithdraw).amount;
}
const actualCoinCost = selectedDenoms
.map((d: DenominationRecord) => Amounts.add(d.value, d.feeWithdraw).amount)
.reduce((a, b) => Amounts.add(a, b).amount);
const exchangeWireAccounts: string[] = [];
for (let account of exchangeWireInfo.accounts) {
exchangeWireAccounts.push(account.url);
}
const { isTrusted, isAudited } = await getExchangeTrust(ws, exchangeInfo);
let earliestDepositExpiration = selectedDenoms[0].stampExpireDeposit;
for (let i = 1; i < selectedDenoms.length; i++) {
const expireDeposit = selectedDenoms[i].stampExpireDeposit;
if (expireDeposit.t_ms < earliestDepositExpiration.t_ms) {
earliestDepositExpiration = expireDeposit;
}
}
const possibleDenoms = await oneShotIterIndex(
ws.db,
Stores.denominations.exchangeBaseUrlIndex,
baseUrl,
).filter(d => d.isOffered);
const trustedAuditorPubs = [];
const currencyRecord = await oneShotGet(
ws.db,
Stores.currencies,
amount.currency,
);
if (currencyRecord) {
trustedAuditorPubs.push(...currencyRecord.auditors.map(a => a.auditorPub));
}
let versionMatch;
if (exchangeDetails.protocolVersion) {
versionMatch = LibtoolVersion.compare(
WALLET_PROTOCOL_VERSION,
exchangeDetails.protocolVersion,
);
if (
versionMatch &&
!versionMatch.compatible &&
versionMatch.currentCmp === -1
) {
console.warn(
`wallet version ${WALLET_PROTOCOL_VERSION} might be outdated ` +
`(exchange has ${exchangeDetails.protocolVersion}), checking for updates`,
);
}
}
const ret: ReserveCreationInfo = {
earliestDepositExpiration,
exchangeInfo,
exchangeWireAccounts,
exchangeVersion: exchangeDetails.protocolVersion || "unknown",
isAudited,
isTrusted,
numOfferedDenoms: possibleDenoms.length,
overhead: Amounts.sub(amount, actualCoinCost).amount,
selectedDenoms,
trustedAuditorPubs,
versionMatch,
walletVersion: WALLET_PROTOCOL_VERSION,
wireFees: exchangeWireInfo,
withdrawFee: acc,
};
return ret;
}
export async function getWithdrawDetailsForUri(
ws: InternalWalletState,
talerWithdrawUri: string,
maybeSelectedExchange?: string,
): Promise<WithdrawDetails> {
const info = await getWithdrawalInfo(ws, talerWithdrawUri);
let rci: ReserveCreationInfo | undefined = undefined;
if (maybeSelectedExchange) {
rci = await getWithdrawDetailsForAmount(
ws,
maybeSelectedExchange,
info.amount,
);
}
return {
withdrawInfo: info,
reserveCreationInfo: rci,
};
}

44
src/wallet-test.ts
View File

@ -14,7 +14,6 @@
TALER; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
*/
import test from "ava";
import * as dbTypes from "./dbTypes";
@ -22,9 +21,9 @@ import * as types from "./walletTypes";
import * as wallet from "./wallet";
import { AmountJson} from "./amounts";
import * as Amounts from "./amounts";
import { AmountJson } from "./util/amounts";
import * as Amounts from "./util/amounts";
import { selectPayCoins } from "./wallet-impl/pay";
function a(x: string): AmountJson {
const amt = Amounts.parse(x);
@ -34,8 +33,11 @@ function a(x: string): AmountJson {
return amt;
}
function fakeCwd(current: string, value: string, feeDeposit: string): types.CoinWithDenom {
function fakeCwd(
current: string,
value: string,
feeDeposit: string,
): types.CoinWithDenom {
return {
coin: {
blindingKey: "(mock)",
@ -71,14 +73,13 @@ function fakeCwd(current: string, value: string, feeDeposit: string): types.Coin
};
}
test("coin selection 1", (t) => {
test("coin selection 1", t => {
const cds: types.CoinWithDenom[] = [
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.1"),
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.0"),
];
const res = wallet.selectPayCoins([], cds, a("EUR:2.0"), a("EUR:0.1"));
const res = selectPayCoins([], cds, a("EUR:2.0"), a("EUR:0.1"));
if (!res) {
t.fail();
return;
@ -87,15 +88,14 @@ test("coin selection 1", (t) => {
t.pass();
});
test("coin selection 2", (t) => {
test("coin selection 2", t => {
const cds: types.CoinWithDenom[] = [
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.0"),
// Merchant covers the fee, this one shouldn't be used
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.0"),
];
const res = wallet.selectPayCoins([], cds, a("EUR:2.0"), a("EUR:0.5"));
const res = selectPayCoins([], cds, a("EUR:2.0"), a("EUR:0.5"));
if (!res) {
t.fail();
return;
@ -104,15 +104,14 @@ test("coin selection 2", (t) => {
t.pass();
});
test("coin selection 3", (t) => {
test("coin selection 3", t => {
const cds: types.CoinWithDenom[] = [
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
// this coin should be selected instead of previous one with fee
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.0"),
];
const res = wallet.selectPayCoins([], cds, a("EUR:2.0"), a("EUR:0.5"));
const res = selectPayCoins([], cds, a("EUR:2.0"), a("EUR:0.5"));
if (!res) {
t.fail();
return;
@ -121,14 +120,13 @@ test("coin selection 3", (t) => {
t.pass();
});
test("coin selection 4", (t) => {
test("coin selection 4", t => {
const cds: types.CoinWithDenom[] = [
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
];
const res = wallet.selectPayCoins([], cds, a("EUR:2.0"), a("EUR:0.2"));
const res = selectPayCoins([], cds, a("EUR:2.0"), a("EUR:0.2"));
if (!res) {
t.fail();
return;
@ -137,25 +135,23 @@ test("coin selection 4", (t) => {
t.pass();
});
test("coin selection 5", (t) => {
test("coin selection 5", t => {
const cds: types.CoinWithDenom[] = [
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
];
const res = wallet.selectPayCoins([], cds, a("EUR:4.0"), a("EUR:0.2"));
const res = selectPayCoins([], cds, a("EUR:4.0"), a("EUR:0.2"));
t.true(!res);
t.pass();
});
test("coin selection 6", (t) => {
test("coin selection 6", t => {
const cds: types.CoinWithDenom[] = [
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
fakeCwd("EUR:1.0", "EUR:1.0", "EUR:0.5"),
];
const res = wallet.selectPayCoins([], cds, a("EUR:2.0"), a("EUR:0.2"));
const res = selectPayCoins([], cds, a("EUR:2.0"), a("EUR:0.2"));
t.true(!res);
t.pass();
});

3767
src/wallet.ts
View File

File diff suppressed because it is too large Load Diff

36
src/walletTypes.ts
View File

@ -25,16 +25,17 @@
/**
* Imports.
*/
import { Checkable } from "./checkable";
import * as LibtoolVersion from "./libtoolVersion";
import { Checkable } from "./util/checkable";
import * as LibtoolVersion from "./util/libtoolVersion";
import { AmountJson } from "./amounts";
import { AmountJson } from "./util/amounts";
import {
CoinRecord,
DenominationRecord,
ExchangeRecord,
ExchangeWireInfo,
WithdrawalSource,
} from "./dbTypes";
import { CoinPaySig, ContractTerms, PayReq } from "./talerTypes";
@ -413,6 +414,7 @@ export interface TipStatus {
nextUrl: string;
exchangeUrl: string;
tipId: string;
merchantTipId: string;
merchantOrigin: string;
expirationTimestamp: number;
timestamp: number;
@ -523,7 +525,7 @@ export interface WalletDiagnostics {
export interface PendingWithdrawOperation {
type: "withdraw";
reservePub: string;
source: WithdrawalSource,
withdrawSessionId: string;
numCoinsWithdrawn: number;
numCoinsTotal: number;
@ -576,13 +578,6 @@ export interface PendingRefreshOperation {
refreshOutputSize: number;
}
export interface PendingPlanchetOperation {
type: "planchet";
coinPub: string;
reservePub: string;
lastError?: OperationError;
}
export interface PendingDirtyCoinOperation {
type: "dirty-coin";
coinPub: string;
@ -595,14 +590,21 @@ export interface PendingProposalOperation {
proposalId: string;
}
export interface PendingTipOperation {
type: "tip";
tipId: string;
merchantBaseUrl: string;
merchantTipId: string;
}
export type PendingOperationInfo =
| PendingWithdrawOperation
| PendingReserveOperation
| PendingBugOperation
| PendingPlanchetOperation
| PendingDirtyCoinOperation
| PendingExchangeUpdateOperation
| PendingRefreshOperation
| PendingTipOperation
| PendingProposalOperation;
export interface PendingOperationsResponse {
@ -642,7 +644,6 @@ export function getTimestampNow(): Timestamp {
};
}
export interface PlanchetCreationResult {
coinPub: string;
coinPriv: string;
@ -652,6 +653,13 @@ export interface PlanchetCreationResult {
blindingKey: string;
withdrawSig: string;
coinEv: string;
exchangeBaseUrl: string;
coinValue: AmountJson;
}
export interface PlanchetCreationRequest {
value: AmountJson;
feeWithdraw: AmountJson;
denomPub: string;
reservePub: string;
reservePriv: string;
}

14
src/webex/messages.ts
View File

@ -21,7 +21,7 @@
// Messages are already documented in wxApi.
/* tslint:disable:completed-docs */
import { AmountJson } from "../amounts";
import { AmountJson } from "../util/amounts";
import * as dbTypes from "../dbTypes";
import * as talerTypes from "../talerTypes";
import * as walletTypes from "../walletTypes";
@ -113,10 +113,6 @@ export interface MessageMap {
request: { reservePub: string };
response: dbTypes.ReserveRecord[];
};
"get-planchets": {
request: { exchangeBaseUrl: string };
response: dbTypes.PlanchetRecord[];
};
"get-denoms": {
request: { exchangeBaseUrl: string };
response: dbTypes.DenominationRecord[];
@ -153,14 +149,6 @@ export interface MessageMap {
request: {};
response: void;
};
"download-proposal": {
request: { url: string };
response: number;
};
"submit-pay": {
request: { contractTermsHash: string; sessionId: string | undefined };
response: walletTypes.ConfirmPayResult;
};
"accept-refund": {
request: { refundUrl: string };
response: string;

28
src/webex/notify.ts
View File

@ -24,8 +24,6 @@
/**
* Imports.
*/
import URI = require("urijs");
import wxApi = require("./wxApi");
declare var cloneInto: any;
@ -180,25 +178,19 @@ function registerHandlers() {
});
addHandler("taler-create-reserve", (msg: any) => {
const params = {
amount: JSON.stringify(msg.amount),
bank_url: document.location.href,
callback_url: new URI(msg.callback_url) .absoluteTo(document.location.href),
suggested_exchange_url: msg.suggested_exchange_url,
wt_types: JSON.stringify(msg.wt_types),
};
const uri = new URI(chrome.extension.getURL("/src/webex/pages/confirm-create-reserve.html"));
const redirectUrl = uri.query(params).href();
window.location.href = redirectUrl;
const uri = new URL(chrome.extension.getURL("/src/webex/pages/confirm-create-reserve.html"));
uri.searchParams.set("amount", JSON.stringify(msg.amount));
uri.searchParams.set("bank_url", document.location.href);
uri.searchParams.set("callback_url", new URL(msg.callback_url, document.location.href).href);
uri.searchParams.set("suggested_exchange_url", msg.suggested_exchange_url);
uri.searchParams.set("wt_types", JSON.stringify(msg.wt_types));
window.location.href = uri.href;
});
addHandler("taler-add-auditor", (msg: any) => {
const params = {
req: JSON.stringify(msg),
};
const uri = new URI(chrome.extension.getURL("/src/webex/pages/add-auditor.html"));
const redirectUrl = uri.query(params).href();
window.location.href = redirectUrl;
const uri = new URL(chrome.extension.getURL("/src/webex/pages/add-auditor.html"));
uri.searchParams.set("req", JSON.stringify(msg))
window.location.href = uri.href;
});
addHandler("taler-confirm-reserve", async (msg: any, sendResponse: any) => {

27
src/webex/pages/add-auditor.tsx
View File

@ -23,7 +23,6 @@
import { CurrencyRecord } from "../../dbTypes";
import { getCurrencies, updateCurrency } from "../wxApi";
import React, { useState } from "react";
import URI = require("urijs");
import { registerMountPage } from "../renderHtml";
interface ConfirmAuditorProps {
@ -118,14 +117,24 @@ function ConfirmAuditor(props: ConfirmAuditorProps) {
registerMountPage(() => {
const walletPageUrl = new URI(document.location.href);
const query: any = JSON.parse(
(URI.parseQuery(walletPageUrl.query()) as any).req,
);
const url = query.url;
const currency: string = query.currency;
const auditorPub: string = query.auditorPub;
const expirationStamp = Number.parseInt(query.expirationStamp);
const walletPageUrl = new URL(document.location.href);
const url = walletPageUrl.searchParams.get("url");
if (!url) {
throw Error("missign parameter (url)");
}
const currency = walletPageUrl.searchParams.get("currency");
if (!currency) {
throw Error("missing parameter (currency)");
}
const auditorPub = walletPageUrl.searchParams.get("auditorPub");
if (!auditorPub) {
throw Error("missing parameter (auditorPub)");
}
const auditorStampStr = walletPageUrl.searchParams.get("expirationStamp");
if (!auditorStampStr) {
throw Error("missing parameter (auditorStampStr)");
}
const expirationStamp = Number.parseInt(auditorStampStr);
const args = { url, currency, auditorPub, expirationStamp };
return <ConfirmAuditor {...args}/>;
});

13
src/webex/pages/pay.tsx
View File

@ -30,9 +30,8 @@ import { renderAmount, ProgressButton, registerMountPage } from "../renderHtml";
import * as wxApi from "../wxApi";
import React, { useState, useEffect } from "react";
import URI = require("urijs");
import * as Amounts from "../../amounts";
import * as Amounts from "../../util/amounts";
function TalerPayDialog({ talerPayUri }: { talerPayUri: string }) {
const [payStatus, setPayStatus] = useState<PreparePayResult | undefined>();
@ -164,10 +163,10 @@ function TalerPayDialog({ talerPayUri }: { talerPayUri: string }) {
}
registerMountPage(() => {
const url = new URI(document.location.href);
const query: any = URI.parseQuery(url.query());
let talerPayUri = query.talerPayUri;
const url = new URL(document.location.href);
const talerPayUri = url.searchParams.get("talerPayUri");
if (!talerPayUri) {
throw Error("invalid parameter");
}
return <TalerPayDialog talerPayUri={talerPayUri} />;
});

20
src/webex/pages/popup.tsx
View File

@ -26,8 +26,8 @@
*/
import * as i18n from "../../i18n";
import { AmountJson } from "../../amounts";
import * as Amounts from "../../amounts";
import { AmountJson } from "../../util/amounts";
import * as Amounts from "../../util/amounts";
import {
HistoryEvent,
@ -44,9 +44,6 @@ import {
import * as wxApi from "../wxApi";
import * as React from "react";
import * as ReactDOM from "react-dom";
import URI = require("urijs");
function onUpdateNotification(f: () => void): () => void {
const port = chrome.runtime.connect({ name: "notifications" });
@ -339,7 +336,7 @@ function formatHistoryItem(historyItem: HistoryEvent) {
</i18n.Translate>
);
case "confirm-reserve": {
const exchange = new URI(d.exchangeBaseUrl).host();
const exchange = new URL(d.exchangeBaseUrl).host;
const pub = abbrev(d.reservePub);
return (
<i18n.Translate wrap="p">
@ -359,7 +356,7 @@ function formatHistoryItem(historyItem: HistoryEvent) {
}
case "depleted-reserve": {
const exchange = d.exchangeBaseUrl
? new URI(d.exchangeBaseUrl).host()
? new URL(d.exchangeBaseUrl).host
: "??";
const amount = renderAmount(d.requestedAmount);
const pub = abbrev(d.reservePub);
@ -396,11 +393,10 @@ function formatHistoryItem(historyItem: HistoryEvent) {
);
}
case "tip": {
const tipPageUrl = new URI(
chrome.extension.getURL("/src/webex/pages/tip.html"),
);
const params = { tip_id: d.tipId, merchant_domain: d.merchantDomain };
const url = tipPageUrl.query(params).href();
const tipPageUrl = new URL(chrome.extension.getURL("/src/webex/pages/tip.html"));
tipPageUrl.searchParams.set("tip_id", d.tipId);
tipPageUrl.searchParams.set("merchant_domain", d.merchantDomain);
const url = tipPageUrl.href;
const tipLink = <a href={url} onClick={openTab(url)}>{i18n.str`tip`}</a>;
// i18n: Tip
return (

6
src/webex/pages/refund.tsx
View File

@ -22,7 +22,6 @@
import React, { useEffect, useState } from "react";
import ReactDOM from "react-dom";
import URI = require("urijs");
import * as wxApi from "../wxApi";
import { PurchaseDetails } from "../../walletTypes";
@ -76,8 +75,7 @@ function RefundStatusView(props: { talerRefundUri: string }) {
}
async function main() {
const url = new URI(document.location.href);
const query: any = URI.parseQuery(url.query());
const url = new URL(document.location.href);
const container = document.getElementById("container");
if (!container) {
@ -85,7 +83,7 @@ async function main() {
return;
}
const talerRefundUri = query.talerRefundUri;
const talerRefundUri = url.searchParams.get("talerRefundUri");
if (!talerRefundUri) {
console.error("taler refund URI requred");
return;

6
src/webex/pages/return-coins.tsx
View File

@ -25,8 +25,8 @@
* Imports.
*/
import { AmountJson } from "../../amounts";
import * as Amounts from "../../amounts";
import { AmountJson } from "../../util/amounts";
import * as Amounts from "../../util/amounts";
import {
SenderWireInfos,
@ -35,7 +35,7 @@ import {
import * as i18n from "../../i18n";
import * as wire from "../../wire";
import * as wire from "../../util/wire";
import {
getBalance,

10
src/webex/pages/tip.tsx
View File

@ -23,7 +23,6 @@
import * as React from "react";
import * as ReactDOM from "react-dom";
import URI = require("urijs");
import * as i18n from "../../i18n";
@ -31,7 +30,7 @@ import { acceptTip, getReserveCreationInfo, getTipStatus } from "../wxApi";
import { WithdrawDetailView, renderAmount, ProgressButton } from "../renderHtml";
import * as Amounts from "../../amounts";
import * as Amounts from "../../util/amounts";
import { useState, useEffect } from "react";
import { TipStatus } from "../../walletTypes";
@ -68,7 +67,7 @@ function TipDisplay(props: { talerTipUri: string }) {
const accept = async () => {
setLoading(true);
await acceptTip(props.talerTipUri);
await acceptTip(tipStatus.tipId);
setFinished(true);
};
@ -101,9 +100,8 @@ function TipDisplay(props: { talerTipUri: string }) {
async function main() {
try {
const url = new URI(document.location.href);
const query: any = URI.parseQuery(url.query());
const talerTipUri = query.talerTipUri;
const url = new URL(document.location.href);
const talerTipUri = url.searchParams.get("talerTipUri");
if (typeof talerTipUri !== "string") {
throw Error("talerTipUri must be a string");
}

6
src/webex/pages/withdraw.tsx
View File

@ -32,7 +32,6 @@ import { WithdrawDetailView, renderAmount } from "../renderHtml";
import React, { useState, useEffect } from "react";
import * as ReactDOM from "react-dom";
import URI = require("urijs");
import { getWithdrawDetails, acceptWithdrawal } from "../wxApi";
function NewExchangeSelection(props: { talerWithdrawUri: string }) {
@ -199,9 +198,8 @@ function NewExchangeSelection(props: { talerWithdrawUri: string }) {
async function main() {
try {
const url = new URI(document.location.href);
const query: any = URI.parseQuery(url.query());
let talerWithdrawUri = query.talerWithdrawUri;
const url = new URL(document.location.href);
const talerWithdrawUri = url.searchParams.get("talerWithdrawUri");
if (!talerWithdrawUri) {
throw Error("withdraw URI required");
}

4
src/webex/renderHtml.tsx
View File

@ -23,8 +23,8 @@
/**
* Imports.
*/
import { AmountJson } from "../amounts";
import * as Amounts from "../amounts";
import { AmountJson } from "../util/amounts";
import * as Amounts from "../util/amounts";
import { DenominationRecord } from "../dbTypes";
import { ReserveCreationInfo } from "../walletTypes";
import * as moment from "moment";

25
src/webex/wxApi.ts
View File

@ -22,7 +22,7 @@
/**
* Imports.
*/
import { AmountJson } from "../amounts";
import { AmountJson } from "../util/amounts";
import {
CoinRecord,
CurrencyRecord,
@ -173,14 +173,6 @@ export function getCoins(exchangeBaseUrl: string): Promise<CoinRecord[]> {
}
/**
* Get all planchets withdrawn from the given exchange.
*/
export function getPlanchets(exchangeBaseUrl: string): Promise<PlanchetRecord[]> {
return callBackend("get-planchets", { exchangeBaseUrl });
}
/**
* Get all denoms offered by the given exchange.
*/
@ -211,13 +203,6 @@ export function confirmPay(proposalId: string, sessionId: string | undefined): P
return callBackend("confirm-pay", { proposalId, sessionId });
}
/**
* Replay paying for a purchase.
*/
export function submitPay(contractTermsHash: string, sessionId: string | undefined): Promise<ConfirmPayResult> {
return callBackend("submit-pay", { contractTermsHash, sessionId });
}
/**
* Mark a reserve as confirmed.
@ -302,14 +287,6 @@ export function clearNotification(): Promise<void> {
return callBackend("clear-notification", { });
}
/**
* Download a contract.
*/
export function downloadProposal(url: string): Promise<number> {
return callBackend("download-proposal", { url });
}
/**
* Download a refund and accept it.
*/

60
src/webex/wxBackend.ts
View File

@ -23,8 +23,8 @@
/**
* Imports.
*/
import { BrowserHttpLib } from "../http";
import { AmountJson } from "../amounts";
import { BrowserHttpLib } from "../util/http";
import { AmountJson } from "../util/amounts";
import {
ConfirmReserveRequest,
CreateReserveRequest,
@ -39,11 +39,10 @@ import { openTalerDb, exportDb, importDb, deleteDb } from "../db";
import { ChromeBadge } from "./chromeBadge";
import { MessageType } from "./messages";
import * as wxApi from "./wxApi";
import URI = require("urijs");
import Port = chrome.runtime.Port;
import MessageSender = chrome.runtime.MessageSender;
import { BrowserCryptoWorkerFactory } from "../crypto/cryptoApi";
import { OpenedPromise, openPromise } from "../promiseUtils";
import { OpenedPromise, openPromise } from "../util/promiseUtils";
const NeedsWallet = Symbol("NeedsWallet");
@ -122,15 +121,6 @@ async function handleMessage(
}
return needsWallet().confirmPay(detail.proposalId, detail.sessionId);
}
case "submit-pay": {
if (typeof detail.contractTermsHash !== "string") {
throw Error("contractTermsHash must be a string");
}
return needsWallet().submitPay(
detail.contractTermsHash,
detail.sessionId,
);
}
case "exchange-info": {
if (!detail.baseUrl) {
return Promise.resolve({ error: "bad url" });
@ -170,7 +160,7 @@ async function handleMessage(
if (typeof detail.reservePub !== "string") {
return Promise.reject(Error("reservePub missing"));
}
return needsWallet().withdrawPaybackReserve(detail.reservePub);
throw Error("not implemented");
}
case "get-coins": {
if (typeof detail.exchangeBaseUrl !== "string") {
@ -178,12 +168,6 @@ async function handleMessage(
}
return needsWallet().getCoinsForExchange(detail.exchangeBaseUrl);
}
case "get-planchets": {
if (typeof detail.exchangeBaseUrl !== "string") {
return Promise.reject(Error("exchangBaseUrl missing"));
}
return needsWallet().getPlanchets(detail.exchangeBaseUrl);
}
case "get-denoms": {
if (typeof detail.exchangeBaseUrl !== "string") {
return Promise.reject(Error("exchangBaseUrl missing"));
@ -244,9 +228,6 @@ async function handleMessage(
case "clear-notification": {
return needsWallet().clearNotification();
}
case "download-proposal": {
return needsWallet().downloadProposal(detail.url);
}
case "abort-failed-payment": {
if (!detail.contractTermsHash) {
throw Error("contracTermsHash not given");
@ -404,18 +385,19 @@ function makeSyncWalletRedirect(
oldUrl: string,
params?: { [name: string]: string | undefined },
): object {
const innerUrl = new URI(chrome.extension.getURL("/src/webex/pages/" + url));
const innerUrl = new URL(chrome.extension.getURL("/src/webex/pages/" + url));
if (params) {
for (const key in params) {
if (params[key]) {
innerUrl.addSearch(key, params[key]);
const p = params[key];
if (p) {
innerUrl.searchParams.set(key, p);
}
}
}
const outerUrl = new URI(
const outerUrl = new URL(
chrome.extension.getURL("/src/webex/pages/redirect.html"),
);
outerUrl.addSearch("url", innerUrl);
outerUrl.searchParams.set("url", innerUrl.href);
if (isFirefox()) {
// Some platforms don't support the sync redirect (yet), so fall back to
// async redirect after a timeout.
@ -423,12 +405,12 @@ function makeSyncWalletRedirect(
await waitMs(150);
const tab = await getTab(tabId);
if (tab.url === oldUrl) {
chrome.tabs.update(tabId, { url: outerUrl.href() });
chrome.tabs.update(tabId, { url: outerUrl.href });
}
};
doit();
}
return { redirectUrl: outerUrl.href() };
return { redirectUrl: outerUrl.href };
}
/**
@ -549,29 +531,29 @@ export async function wxMain() {
if (!tab.url || !tab.id) {
continue;
}
const uri = new URI(tab.url);
if (uri.protocol() !== "http" && uri.protocol() !== "https") {
const uri = new URL(tab.url);
if (uri.protocol !== "http:" && uri.protocol !== "https:") {
continue;
}
console.log(
"injecting into existing tab",
tab.id,
"with url",
uri.href(),
uri.href,
"protocol",
uri.protocol(),
uri.protocol,
);
injectScript(
tab.id,
{ file: "/dist/contentScript-bundle.js", runAt: "document_start" },
uri.href(),
uri.href,
);
const code = `
if (("taler" in window) || document.documentElement.getAttribute("data-taler-nojs")) {
document.dispatchEvent(new Event("taler-probe-result"));
}
`;
injectScript(tab.id, { code, runAt: "document_start" }, uri.href());
injectScript(tab.id, { code, runAt: "document_start" }, uri.href);
}
});
@ -603,8 +585,8 @@ export async function wxMain() {
if (!tab.url || !tab.id) {
return;
}
const uri = new URI(tab.url);
if (!(uri.protocol() === "http" || uri.protocol() === "https")) {
const uri = new URL(tab.url);
if (!(uri.protocol === "http:" || uri.protocol === "https:")) {
return;
}
const code = `
@ -612,7 +594,7 @@ export async function wxMain() {
document.dispatchEvent(new Event("taler-probe-result"));
}
`;
injectScript(tab.id!, { code, runAt: "document_start" }, uri.href());
injectScript(tab.id!, { code, runAt: "document_start" }, uri.href);
});
};

47
tsconfig.json
View File

@ -23,9 +23,7 @@
"esModuleInterop": true
},
"files": [
"src/amounts.ts",
"src/android/index.ts",
"src/checkable.ts",
"src/crypto/browserWorkerEntry.ts",
"src/crypto/cryptoApi.ts",
"src/crypto/cryptoImplementation.ts",
@ -46,22 +44,42 @@
"src/headless/integrationtest.ts",
"src/headless/merchant.ts",
"src/headless/taler-wallet-cli.ts",
"src/helpers-test.ts",
"src/helpers.ts",
"src/http.ts",
"src/i18n.tsx",
"src/i18n/strings.ts",
"src/index.ts",
"src/libtoolVersion-test.ts",
"src/libtoolVersion.ts",
"src/logging.ts",
"src/promiseUtils.ts",
"src/query.ts",
"src/talerTypes.ts",
"src/taleruri-test.ts",
"src/taleruri.ts",
"src/timer.ts",
"src/types-test.ts",
"src/util/amounts.ts",
"src/util/assertUnreachable.ts",
"src/util/asyncMemo.ts",
"src/util/checkable.ts",
"src/util/helpers-test.ts",
"src/util/helpers.ts",
"src/util/http.ts",
"src/util/libtoolVersion-test.ts",
"src/util/libtoolVersion.ts",
"src/util/logging.ts",
"src/util/payto-test.ts",
"src/util/payto.ts",
"src/util/promiseUtils.ts",
"src/util/query.ts",
"src/util/taleruri-test.ts",
"src/util/taleruri.ts",
"src/util/timer.ts",
"src/util/wire.ts",
"src/wallet-impl/balance.ts",
"src/wallet-impl/exchanges.ts",
"src/wallet-impl/history.ts",
"src/wallet-impl/pay.ts",
"src/wallet-impl/payback.ts",
"src/wallet-impl/pending.ts",
"src/wallet-impl/refresh.ts",
"src/wallet-impl/refund.ts",
"src/wallet-impl/reserves.ts",
"src/wallet-impl/return.ts",
"src/wallet-impl/state.ts",
"src/wallet-impl/tip.ts",
"src/wallet-impl/withdraw.ts",
"src/wallet-test.ts",
"src/wallet.ts",
"src/walletTypes.ts",
@ -86,7 +104,6 @@
"src/webex/pages/withdraw.tsx",
"src/webex/renderHtml.tsx",
"src/webex/wxApi.ts",
"src/webex/wxBackend.ts",
"src/wire.ts"
"src/webex/wxBackend.ts"
]
}

10
yarn.lock
View File

@ -394,11 +394,6 @@
"@types/prop-types" "*"
csstype "^2.2.0"
"@types/urijs@^1.19.3":
version "1.19.4"
resolved "https://registry.yarnpkg.com/@types/urijs/-/urijs-1.19.4.tgz#29c4a694d4842d7f95e359a26223fc1865f1ab13"
integrity sha512-uHUvuLfy4YkRHL4UH8J8oRsINhdEHd9ymag7KJZVT94CjAmY1njoUzhazJsZjwfy+IpWKQKGVyXCwzhZvg73Fg==
"@webassemblyjs/ast@1.8.5":
version "1.8.5"
resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.8.5.tgz#51b1c5fe6576a34953bf4b253df9f0d490d9e359"
@ -7084,11 +7079,6 @@ uri-js@^4.2.2:
dependencies:
punycode "^2.1.0"
urijs@^1.18.10:
version "1.19.2"
resolved "https://registry.yarnpkg.com/urijs/-/urijs-1.19.2.tgz#f9be09f00c4c5134b7cb3cf475c1dd394526265a"
integrity sha512-s/UIq9ap4JPZ7H1EB5ULo/aOUbWqfDi7FKzMC2Nz+0Si8GiT1rIEaprt8hy3Vy2Ex2aJPpOQv4P4DuOZ+K1c6w==
urix@^0.1.0:
version "0.1.0"
resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72"