summaryrefslogtreecommitdiff
path: root/src/operations
diff options
context:
space:
mode:
Diffstat (limited to 'src/operations')
-rw-r--r--src/operations/history.ts120
-rw-r--r--src/operations/pay.ts9
-rw-r--r--src/operations/recoup.ts1
-rw-r--r--src/operations/refresh.ts12
-rw-r--r--src/operations/refund.ts340
-rw-r--r--src/operations/transactions.ts121
6 files changed, 265 insertions, 338 deletions
diff --git a/src/operations/history.ts b/src/operations/history.ts
index 9cbbd5163..8fff4f888 100644
--- a/src/operations/history.ts
+++ b/src/operations/history.ts
@@ -421,66 +421,66 @@ export async function getHistory(
}
});
- tx.iter(Stores.refundEvents).forEachAsync(async (re) => {
- const proposal = await tx.get(Stores.proposals, re.proposalId);
- if (!proposal) {
- return;
- }
- const purchase = await tx.get(Stores.purchases, re.proposalId);
- if (!purchase) {
- return;
- }
- const orderShortInfo = getOrderShortInfo(proposal);
- if (!orderShortInfo) {
- return;
- }
- const purchaseAmount = purchase.contractData.amount;
- let amountRefundedRaw = Amounts.getZero(purchaseAmount.currency);
- let amountRefundedInvalid = Amounts.getZero(purchaseAmount.currency);
- let amountRefundedEffective = Amounts.getZero(purchaseAmount.currency);
- Object.keys(purchase.refundsDone).forEach((x, i) => {
- const r = purchase.refundsDone[x];
- if (r.refundGroupId !== re.refundGroupId) {
- return;
- }
- const refundAmount = Amounts.parseOrThrow(r.perm.refund_amount);
- const refundFee = Amounts.parseOrThrow(r.perm.refund_fee);
- amountRefundedRaw = Amounts.add(amountRefundedRaw, refundAmount)
- .amount;
- amountRefundedEffective = Amounts.add(
- amountRefundedEffective,
- refundAmount,
- ).amount;
- amountRefundedEffective = Amounts.sub(
- amountRefundedEffective,
- refundFee,
- ).amount;
- });
- Object.keys(purchase.refundsFailed).forEach((x, i) => {
- const r = purchase.refundsFailed[x];
- if (r.refundGroupId !== re.refundGroupId) {
- return;
- }
- const ra = Amounts.parseOrThrow(r.perm.refund_amount);
- const refundFee = Amounts.parseOrThrow(r.perm.refund_fee);
- amountRefundedRaw = Amounts.add(amountRefundedRaw, ra).amount;
- amountRefundedInvalid = Amounts.add(amountRefundedInvalid, ra).amount;
- amountRefundedEffective = Amounts.sub(
- amountRefundedEffective,
- refundFee,
- ).amount;
- });
- history.push({
- type: HistoryEventType.Refund,
- eventId: makeEventId(HistoryEventType.Refund, re.refundGroupId),
- refundGroupId: re.refundGroupId,
- orderShortInfo,
- timestamp: re.timestamp,
- amountRefundedEffective: Amounts.stringify(amountRefundedEffective),
- amountRefundedRaw: Amounts.stringify(amountRefundedRaw),
- amountRefundedInvalid: Amounts.stringify(amountRefundedInvalid),
- });
- });
+ // tx.iter(Stores.refundEvents).forEachAsync(async (re) => {
+ // const proposal = await tx.get(Stores.proposals, re.proposalId);
+ // if (!proposal) {
+ // return;
+ // }
+ // const purchase = await tx.get(Stores.purchases, re.proposalId);
+ // if (!purchase) {
+ // return;
+ // }
+ // const orderShortInfo = getOrderShortInfo(proposal);
+ // if (!orderShortInfo) {
+ // return;
+ // }
+ // const purchaseAmount = purchase.contractData.amount;
+ // let amountRefundedRaw = Amounts.getZero(purchaseAmount.currency);
+ // let amountRefundedInvalid = Amounts.getZero(purchaseAmount.currency);
+ // let amountRefundedEffective = Amounts.getZero(purchaseAmount.currency);
+ // Object.keys(purchase.refundsDone).forEach((x, i) => {
+ // const r = purchase.refundsDone[x];
+ // if (r.refundGroupId !== re.refundGroupId) {
+ // return;
+ // }
+ // const refundAmount = Amounts.parseOrThrow(r.perm.refund_amount);
+ // const refundFee = Amounts.parseOrThrow(r.perm.refund_fee);
+ // amountRefundedRaw = Amounts.add(amountRefundedRaw, refundAmount)
+ // .amount;
+ // amountRefundedEffective = Amounts.add(
+ // amountRefundedEffective,
+ // refundAmount,
+ // ).amount;
+ // amountRefundedEffective = Amounts.sub(
+ // amountRefundedEffective,
+ // refundFee,
+ // ).amount;
+ // });
+ // Object.keys(purchase.refundsFailed).forEach((x, i) => {
+ // const r = purchase.refundsFailed[x];
+ // if (r.refundGroupId !== re.refundGroupId) {
+ // return;
+ // }
+ // const ra = Amounts.parseOrThrow(r.perm.refund_amount);
+ // const refundFee = Amounts.parseOrThrow(r.perm.refund_fee);
+ // amountRefundedRaw = Amounts.add(amountRefundedRaw, ra).amount;
+ // amountRefundedInvalid = Amounts.add(amountRefundedInvalid, ra).amount;
+ // amountRefundedEffective = Amounts.sub(
+ // amountRefundedEffective,
+ // refundFee,
+ // ).amount;
+ // });
+ // history.push({
+ // type: HistoryEventType.Refund,
+ // eventId: makeEventId(HistoryEventType.Refund, re.refundGroupId),
+ // refundGroupId: re.refundGroupId,
+ // orderShortInfo,
+ // timestamp: re.timestamp,
+ // amountRefundedEffective: Amounts.stringify(amountRefundedEffective),
+ // amountRefundedRaw: Amounts.stringify(amountRefundedRaw),
+ // amountRefundedInvalid: Amounts.stringify(amountRefundedInvalid),
+ // });
+ // });
tx.iter(Stores.recoupGroups).forEach((rg) => {
if (rg.timestampFinished) {
diff --git a/src/operations/pay.ts b/src/operations/pay.ts
index 29b697833..0027bf0f3 100644
--- a/src/operations/pay.ts
+++ b/src/operations/pay.ts
@@ -59,7 +59,6 @@ import { InternalWalletState } from "./state";
import { getTimestampNow, timestampAddDuration } from "../util/time";
import { strcmp, canonicalJson } from "../util/helpers";
import {
- readSuccessResponseJsonOrErrorCode,
readSuccessResponseJsonOrThrow,
} from "../util/http";
@@ -455,11 +454,7 @@ async function recordConfirmPay(
timestampFirstSuccessfulPay: undefined,
autoRefundDeadline: undefined,
paymentSubmitPending: true,
- refundGroups: [],
- refundsDone: {},
- refundsFailed: {},
- refundsPending: {},
- refundsRefreshCost: {},
+ refunds: {},
};
await ws.db.runWithWriteTransaction(
@@ -492,7 +487,7 @@ async function recordConfirmPay(
const refreshCoinPubs = coinSelection.coinPubs.map((x) => ({
coinPub: x,
}));
- await createRefreshGroup(tx, refreshCoinPubs, RefreshReason.Pay);
+ await createRefreshGroup(ws, tx, refreshCoinPubs, RefreshReason.Pay);
},
);
diff --git a/src/operations/recoup.ts b/src/operations/recoup.ts
index 445d029cd..e5f14c6ee 100644
--- a/src/operations/recoup.ts
+++ b/src/operations/recoup.ts
@@ -96,6 +96,7 @@ async function putGroupAsFinished(
recoupGroup.lastError = undefined;
if (recoupGroup.scheduleRefreshCoins.length > 0) {
const refreshGroupId = await createRefreshGroup(
+ ws,
tx,
recoupGroup.scheduleRefreshCoins.map((x) => ({ coinPub: x })),
RefreshReason.Recoup,
diff --git a/src/operations/refresh.ts b/src/operations/refresh.ts
index 4d477d644..74b032b91 100644
--- a/src/operations/refresh.ts
+++ b/src/operations/refresh.ts
@@ -535,6 +535,7 @@ async function processRefreshSession(
* Create a refresh group for a list of coins.
*/
export async function createRefreshGroup(
+ ws: InternalWalletState,
tx: TransactionHandle,
oldCoinPubs: CoinPublicKey[],
reason: RefreshReason,
@@ -554,6 +555,17 @@ export async function createRefreshGroup(
};
await tx.put(Stores.refreshGroups, refreshGroup);
+
+ const processAsync = async (): Promise<void> => {
+ try {
+ await processRefreshGroup(ws, refreshGroupId);
+ } catch (e) {
+ logger.trace(`Error during refresh: ${e}`)
+ }
+ };
+
+ processAsync();
+
return {
refreshGroupId,
};
diff --git a/src/operations/refund.ts b/src/operations/refund.ts
index 1d6561bdc..af3325cfd 100644
--- a/src/operations/refund.ts
+++ b/src/operations/refund.ts
@@ -36,23 +36,24 @@ import {
CoinStatus,
RefundReason,
RefundEventRecord,
+ RefundState,
+ PurchaseRecord,
} from "../types/dbTypes";
import { NotificationType } from "../types/notifications";
import { parseRefundUri } from "../util/taleruri";
import { createRefreshGroup, getTotalRefreshCost } from "./refresh";
import { Amounts } from "../util/amounts";
import {
- MerchantRefundDetails,
- MerchantRefundResponse,
- codecForMerchantRefundResponse,
+ codecForMerchantOrderStatus,
+ MerchantCoinRefundStatus,
+ MerchantCoinRefundSuccessStatus,
+ MerchantCoinRefundFailureStatus,
} from "../types/talerTypes";
-import { AmountJson } from "../util/amounts";
import { guardOperationException } from "./errors";
-import { randomBytes } from "../crypto/primitives/nacl-fast";
-import { encodeCrock } from "../crypto/talerCrypto";
import { getTimestampNow } from "../util/time";
import { Logger } from "../util/logging";
import { readSuccessResponseJsonOrThrow } from "../util/http";
+import { TransactionHandle } from "../util/query";
const logger = new Logger("refund.ts");
@@ -85,80 +86,122 @@ async function incrementPurchaseQueryRefundRetry(
}
}
-function getRefundKey(d: MerchantRefundDetails): string {
+function getRefundKey(d: MerchantCoinRefundStatus): string {
return `${d.coin_pub}-${d.rtransaction_id}`;
}
-async function acceptRefundResponse(
- ws: InternalWalletState,
- proposalId: string,
- refundResponse: MerchantRefundResponse,
- reason: RefundReason,
+async function applySuccessfulRefund(
+ tx: TransactionHandle,
+ p: PurchaseRecord,
+ refreshCoinsMap: Record<string, { coinPub: string }>,
+ r: MerchantCoinRefundSuccessStatus,
): Promise<void> {
- const refunds = refundResponse.refunds;
-
- const refundGroupId = encodeCrock(randomBytes(32));
+ // FIXME: check signature before storing it as valid!
- let numNewRefunds = 0;
-
- const finishedRefunds: MerchantRefundDetails[] = [];
- const unfinishedRefunds: MerchantRefundDetails[] = [];
- const failedRefunds: MerchantRefundDetails[] = [];
+ const refundKey = getRefundKey(r);
+ const coin = await tx.get(Stores.coins, r.coin_pub);
+ if (!coin) {
+ console.warn("coin not found, can't apply refund");
+ return;
+ }
+ const denom = await tx.getIndexed(
+ Stores.denominations.denomPubHashIndex,
+ coin.denomPubHash,
+ );
+ if (!denom) {
+ throw Error("inconsistent database");
+ }
+ refreshCoinsMap[coin.coinPub] = { coinPub: coin.coinPub };
+ const refundAmount = Amounts.parseOrThrow(r.refund_amount);
+ const refundFee = denom.feeRefund;
+ coin.status = CoinStatus.Dormant;
+ coin.currentAmount = Amounts.add(coin.currentAmount, refundAmount).amount;
+ coin.currentAmount = Amounts.sub(coin.currentAmount, refundFee).amount;
+ logger.trace(`coin amount after is ${Amounts.stringify(coin.currentAmount)}`);
+ await tx.put(Stores.coins, coin);
+
+ const allDenoms = await tx
+ .iterIndexed(Stores.denominations.exchangeBaseUrlIndex, coin.exchangeBaseUrl)
+ .toArray();
+
+ const amountLeft = Amounts.sub(
+ Amounts.add(coin.currentAmount, Amounts.parseOrThrow(r.refund_amount))
+ .amount,
+ denom.feeRefund,
+ ).amount;
+
+ const totalRefreshCostBound = getTotalRefreshCost(
+ allDenoms,
+ denom,
+ amountLeft,
+ );
- console.log("handling refund response", refundResponse);
+ p.refunds[refundKey] = {
+ type: RefundState.Applied,
+ executionTime: r.execution_time,
+ refundAmount: Amounts.parseOrThrow(r.refund_amount),
+ refundFee: denom.feeRefund,
+ totalRefreshCostBound,
+ };
+}
- const refundsRefreshCost: { [refundKey: string]: AmountJson } = {};
+async function storePendingRefund(
+ tx: TransactionHandle,
+ p: PurchaseRecord,
+ r: MerchantCoinRefundFailureStatus,
+): Promise<void> {
+ const refundKey = getRefundKey(r);
- for (const rd of refunds) {
- logger.trace(
- `Refund ${rd.rtransaction_id} has HTTP status ${rd.exchange_http_status}`,
- );
- if (rd.exchange_http_status === 200) {
- // FIXME: also verify signature if necessary.
- finishedRefunds.push(rd);
- } else if (
- rd.exchange_http_status >= 400 &&
- rd.exchange_http_status < 400
- ) {
- failedRefunds.push(rd);
- } else {
- unfinishedRefunds.push(rd);
- }
+ const coin = await tx.get(Stores.coins, r.coin_pub);
+ if (!coin) {
+ console.warn("coin not found, can't apply refund");
+ return;
}
+ const denom = await tx.getIndexed(
+ Stores.denominations.denomPubHashIndex,
+ coin.denomPubHash,
+ );
- // Compute cost.
- // FIXME: Optimize, don't always recompute.
- for (const rd of [...finishedRefunds, ...unfinishedRefunds]) {
- const key = getRefundKey(rd);
- const coin = await ws.db.get(Stores.coins, rd.coin_pub);
- if (!coin) {
- continue;
- }
- const denom = await ws.db.getIndexed(
- Stores.denominations.denomPubHashIndex,
- coin.denomPubHash,
- );
- if (!denom) {
- throw Error("inconsistent database");
- }
- const amountLeft = Amounts.sub(
- Amounts.add(coin.currentAmount, Amounts.parseOrThrow(rd.refund_amount))
- .amount,
- Amounts.parseOrThrow(rd.refund_fee),
- ).amount;
- const allDenoms = await ws.db
- .iterIndex(
- Stores.denominations.exchangeBaseUrlIndex,
- coin.exchangeBaseUrl,
- )
- .toArray();
- refundsRefreshCost[key] = getTotalRefreshCost(allDenoms, denom, amountLeft);
+ if (!denom) {
+ throw Error("inconsistent database");
}
+ const allDenoms = await tx
+ .iterIndexed(Stores.denominations.exchangeBaseUrlIndex, coin.exchangeBaseUrl)
+ .toArray();
+
+ const amountLeft = Amounts.sub(
+ Amounts.add(coin.currentAmount, Amounts.parseOrThrow(r.refund_amount))
+ .amount,
+ denom.feeRefund,
+ ).amount;
+
+ const totalRefreshCostBound = getTotalRefreshCost(
+ allDenoms,
+ denom,
+ amountLeft,
+ );
+
+ p.refunds[refundKey] = {
+ type: RefundState.Pending,
+ executionTime: r.execution_time,
+ refundAmount: Amounts.parseOrThrow(r.refund_amount),
+ refundFee: denom.feeRefund,
+ totalRefreshCostBound,
+ };
+}
+
+async function acceptRefunds(
+ ws: InternalWalletState,
+ proposalId: string,
+ refunds: MerchantCoinRefundStatus[],
+ reason: RefundReason,
+): Promise<void> {
+ console.log("handling refunds", refunds);
const now = getTimestampNow();
await ws.db.runWithWriteTransaction(
- [Stores.purchases, Stores.coins, Stores.refreshGroups, Stores.refundEvents],
+ [Stores.purchases, Stores.coins, Stores.denominations, Stores.refreshGroups, Stores.refundEvents],
async (tx) => {
const p = await tx.get(Stores.purchases, proposalId);
if (!p) {
@@ -166,103 +209,60 @@ async function acceptRefundResponse(
return;
}
- // Groups that newly failed/succeeded
- const changedGroups: { [refundGroupId: string]: boolean } = {};
+ const refreshCoinsMap: Record<string, CoinPublicKey> = {};
- for (const rd of failedRefunds) {
- const refundKey = getRefundKey(rd);
- if (p.refundsFailed[refundKey]) {
+ for (const refundStatus of refunds) {
+ const refundKey = getRefundKey(refundStatus);
+ const existingRefundInfo = p.refunds[refundKey];
+
+ // Already failed.
+ if (existingRefundInfo?.type === RefundState.Failed) {
continue;
}
- if (!p.refundsFailed[refundKey]) {
- p.refundsFailed[refundKey] = {
- perm: rd,
- refundGroupId,
- };
- numNewRefunds++;
- changedGroups[refundGroupId] = true;
- }
- const oldPending = p.refundsPending[refundKey];
- if (oldPending) {
- delete p.refundsPending[refundKey];
- changedGroups[oldPending.refundGroupId] = true;
- }
- }
- for (const rd of unfinishedRefunds) {
- const refundKey = getRefundKey(rd);
- if (!p.refundsPending[refundKey]) {
- p.refundsPending[refundKey] = {
- perm: rd,
- refundGroupId,
- };
- numNewRefunds++;
+ // Already applied.
+ if (existingRefundInfo?.type === RefundState.Applied) {
+ continue;
}
- }
- // Avoid duplicates
- const refreshCoinsMap: { [coinPub: string]: CoinPublicKey } = {};
-
- for (const rd of finishedRefunds) {
- const refundKey = getRefundKey(rd);
- if (p.refundsDone[refundKey]) {
+ // Still pending.
+ if (
+ refundStatus.success === false &&
+ existingRefundInfo?.type === RefundState.Pending
+ ) {
continue;
}
- p.refundsDone[refundKey] = {
- perm: rd,
- refundGroupId,
- };
- const oldPending = p.refundsPending[refundKey];
- if (oldPending) {
- delete p.refundsPending[refundKey];
- changedGroups[oldPending.refundGroupId] = true;
- } else {
- numNewRefunds++;
- }
- const c = await tx.get(Stores.coins, rd.coin_pub);
+ // Invariant: (!existingRefundInfo) || (existingRefundInfo === Pending)
- if (!c) {
- console.warn("coin not found, can't apply refund");
- return;
+ if (refundStatus.success === true) {
+ await applySuccessfulRefund(tx, p, refreshCoinsMap, refundStatus);
+ } else {
+ await storePendingRefund(tx, p, refundStatus);
}
- refreshCoinsMap[c.coinPub] = { coinPub: c.coinPub };
- logger.trace(`commiting refund ${refundKey} to coin ${c.coinPub}`);
- logger.trace(
- `coin amount before is ${Amounts.stringify(c.currentAmount)}`,
- );
- logger.trace(`refund amount (via merchant) is ${refundKey}`);
- logger.trace(`refund fee (via merchant) is ${refundKey}`);
- const refundAmount = Amounts.parseOrThrow(rd.refund_amount);
- const refundFee = Amounts.parseOrThrow(rd.refund_fee);
- c.status = CoinStatus.Dormant;
- c.currentAmount = Amounts.add(c.currentAmount, refundAmount).amount;
- c.currentAmount = Amounts.sub(c.currentAmount, refundFee).amount;
- logger.trace(
- `coin amount after is ${Amounts.stringify(c.currentAmount)}`,
- );
- await tx.put(Stores.coins, c);
}
+ const refreshCoinsPubs = Object.values(refreshCoinsMap);
+ await createRefreshGroup(ws, tx, refreshCoinsPubs, RefreshReason.Refund);
+
// Are we done with querying yet, or do we need to do another round
// after a retry delay?
let queryDone = true;
- logger.trace(`got ${numNewRefunds} new refund permissions`);
+ if (p.autoRefundDeadline && p.autoRefundDeadline.t_ms > now.t_ms) {
+ queryDone = false;
+ }
- if (numNewRefunds === 0) {
- if (p.autoRefundDeadline && p.autoRefundDeadline.t_ms > now.t_ms) {
- queryDone = false;
+ let numPendingRefunds = 0;
+ for (const ri of Object.values(p.refunds)) {
+ switch (ri.type) {
+ case RefundState.Pending:
+ numPendingRefunds++;
+ break;
}
- } else {
- p.refundGroups.push({
- reason: RefundReason.NormalRefund,
- refundGroupId,
- timestampQueried: getTimestampNow(),
- });
}
- if (Object.keys(unfinishedRefunds).length != 0) {
+ if (numPendingRefunds > 0) {
queryDone = false;
}
@@ -281,38 +281,7 @@ async function acceptRefundResponse(
logger.trace("refund query not done");
}
- p.refundsRefreshCost = { ...p.refundsRefreshCost, ...refundsRefreshCost };
-
await tx.put(Stores.purchases, p);
-
- const coinsPubsToBeRefreshed = Object.values(refreshCoinsMap);
- if (coinsPubsToBeRefreshed.length > 0) {
- await createRefreshGroup(
- tx,
- coinsPubsToBeRefreshed,
- RefreshReason.Refund,
- );
- }
-
- // Check if any of the refund groups are done, and we
- // can emit an corresponding event.
- for (const g of Object.keys(changedGroups)) {
- let groupDone = true;
- for (const pk of Object.keys(p.refundsPending)) {
- const r = p.refundsPending[pk];
- if (r.refundGroupId == g) {
- groupDone = false;
- }
- }
- if (groupDone) {
- const refundEvent: RefundEventRecord = {
- proposalId,
- refundGroupId: g,
- timestamp: now,
- };
- await tx.put(Stores.refundEvents, refundEvent);
- }
- }
},
);
@@ -430,22 +399,33 @@ async function processPurchaseQueryRefundImpl(
return;
}
- const request = await ws.http.get(
- new URL(
- `orders/${purchase.contractData.orderId}`,
- purchase.contractData.merchantBaseUrl,
- ).href,
+ const requestUrl = new URL(
+ `orders/${purchase.contractData.orderId}`,
+ purchase.contractData.merchantBaseUrl,
+ );
+ requestUrl.searchParams.set(
+ "h_contract",
+ purchase.contractData.contractTermsHash,
);
+ const request = await ws.http.get(requestUrl.href);
+
+ console.log("got json", JSON.stringify(await request.json(), undefined, 2));
+
const refundResponse = await readSuccessResponseJsonOrThrow(
request,
- codecForMerchantRefundResponse(),
+ codecForMerchantOrderStatus(),
);
- await acceptRefundResponse(
+ if (!refundResponse.paid) {
+ logger.error("can't refund unpaid order");
+ return;
+ }
+
+ await acceptRefunds(
ws,
proposalId,
- refundResponse,
+ refundResponse.refunds,
RefundReason.NormalRefund,
);
}
diff --git a/src/operations/transactions.ts b/src/operations/transactions.ts
index f104f1078..fb0629660 100644
--- a/src/operations/transactions.ts
+++ b/src/operations/transactions.ts
@@ -44,68 +44,6 @@ function makeEventId(type: TransactionType, ...args: string[]): string {
return type + ";" + args.map((x) => encodeURIComponent(x)).join(";");
}
-interface RefundStats {
- amountInvalid: AmountJson;
- amountEffective: AmountJson;
- amountRaw: AmountJson;
-}
-
-function getRefundStats(
- pr: PurchaseRecord,
- refundGroupId: string,
-): RefundStats {
- let amountEffective = Amounts.getZero(pr.contractData.amount.currency);
- let amountInvalid = Amounts.getZero(pr.contractData.amount.currency);
- let amountRaw = Amounts.getZero(pr.contractData.amount.currency);
-
- for (const rk of Object.keys(pr.refundsDone)) {
- const perm = pr.refundsDone[rk].perm;
- if (pr.refundsDone[rk].refundGroupId !== refundGroupId) {
- continue;
- }
- amountEffective = Amounts.add(
- amountEffective,
- Amounts.parseOrThrow(perm.refund_amount),
- ).amount;
- amountRaw = Amounts.add(amountRaw, Amounts.parseOrThrow(perm.refund_amount))
- .amount;
- }
-
- // Subtract fees from effective refund amount
-
- for (const rk of Object.keys(pr.refundsDone)) {
- const perm = pr.refundsDone[rk].perm;
- if (pr.refundsDone[rk].refundGroupId !== refundGroupId) {
- continue;
- }
- amountEffective = Amounts.sub(
- amountEffective,
- Amounts.parseOrThrow(perm.refund_fee),
- ).amount;
- if (pr.refundsRefreshCost[rk]) {
- amountEffective = Amounts.sub(amountEffective, pr.refundsRefreshCost[rk])
- .amount;
- }
- }
-
- for (const rk of Object.keys(pr.refundsFailed)) {
- const perm = pr.refundsDone[rk].perm;
- if (pr.refundsDone[rk].refundGroupId !== refundGroupId) {
- continue;
- }
- amountInvalid = Amounts.add(
- amountInvalid,
- Amounts.parseOrThrow(perm.refund_fee),
- ).amount;
- }
-
- return {
- amountEffective,
- amountInvalid,
- amountRaw,
- };
-}
-
function shouldSkipCurrency(
transactionsRequest: TransactionsRequest | undefined,
currency: string,
@@ -319,36 +257,37 @@ export async function getTransactions(
},
});
- for (const rg of pr.refundGroups) {
- const pending = Object.keys(pr.refundsPending).length > 0;
- const stats = getRefundStats(pr, rg.refundGroupId);
+ // for (const rg of pr.refundGroups) {
+ // const pending = Object.keys(pr.refundsPending).length > 0;
+ // const stats = getRefundStats(pr, rg.refundGroupId);
+
+ // transactions.push({
+ // type: TransactionType.Refund,
+ // pending,
+ // info: {
+ // fulfillmentUrl: pr.contractData.fulfillmentUrl,
+ // merchant: pr.contractData.merchant,
+ // orderId: pr.contractData.orderId,
+ // products: pr.contractData.products,
+ // summary: pr.contractData.summary,
+ // summary_i18n: pr.contractData.summaryI18n,
+ // },
+ // timestamp: rg.timestampQueried,
+ // transactionId: makeEventId(
+ // TransactionType.Refund,
+ // pr.proposalId,
+ // `${rg.timestampQueried.t_ms}`,
+ // ),
+ // refundedTransactionId: makeEventId(
+ // TransactionType.Payment,
+ // pr.proposalId,
+ // ),
+ // amountEffective: Amounts.stringify(stats.amountEffective),
+ // amountInvalid: Amounts.stringify(stats.amountInvalid),
+ // amountRaw: Amounts.stringify(stats.amountRaw),
+ // });
+ // }
- transactions.push({
- type: TransactionType.Refund,
- pending,
- info: {
- fulfillmentUrl: pr.contractData.fulfillmentUrl,
- merchant: pr.contractData.merchant,
- orderId: pr.contractData.orderId,
- products: pr.contractData.products,
- summary: pr.contractData.summary,
- summary_i18n: pr.contractData.summaryI18n,
- },
- timestamp: rg.timestampQueried,
- transactionId: makeEventId(
- TransactionType.Refund,
- pr.proposalId,
- `${rg.timestampQueried.t_ms}`,
- ),
- refundedTransactionId: makeEventId(
- TransactionType.Payment,
- pr.proposalId,
- ),
- amountEffective: Amounts.stringify(stats.amountEffective),
- amountInvalid: Amounts.stringify(stats.amountInvalid),
- amountRaw: Amounts.stringify(stats.amountRaw),
- });
- }
});
},
);
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-17 07:34:56 +0000