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

wallet-core: address DB FIXMEs, systematic state numbering

Browse Source
This commit is contained in:
Florian Dold 2023-09-07 20:35:46 +02:00
parent 33f2798004
commit c660db82c1
No known key found for this signature in database
GPG Key ID: D2E4F00F29D02A4B
24 changed files with 995 additions and 1126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
packages/taler-harness/src/integrationtests/test-peer-repair.ts
View File

@ -130,7 +130,7 @@ export async function runPeerRepairTest(t: GlobalTestState) {
); );
await wallet2.client.call(WalletApiOperation.ConfirmPeerPushCredit, { await wallet2.client.call(WalletApiOperation.ConfirmPeerPushCredit, {
peerPushPaymentIncomingId: resp2.peerPushPaymentIncomingId, peerPushCreditId: resp2.peerPushCreditId,
}); });
await peerPushCreditDone1Cond; await peerPushCreditDone1Cond;

2
packages/taler-harness/src/integrationtests/test-peer-to-peer-pull.ts
View File

@ -123,7 +123,7 @@ export async function runPeerToPeerPullTest(t: GlobalTestState) {
); );
await wallet2.client.call(WalletApiOperation.ConfirmPeerPullDebit, { await wallet2.client.call(WalletApiOperation.ConfirmPeerPullDebit, {
peerPullPaymentIncomingId: checkResp.peerPullPaymentIncomingId, peerPullDebitId: checkResp.peerPullDebitId,
}); });
await peerPullCreditDoneCond; await peerPullCreditDoneCond;

2
packages/taler-harness/src/integrationtests/test-peer-to-peer-push.ts
View File

@ -126,7 +126,7 @@ export async function runPeerToPeerPushTest(t: GlobalTestState) {
const acceptResp = await w2.walletClient.call( const acceptResp = await w2.walletClient.call(
WalletApiOperation.ConfirmPeerPushCredit, WalletApiOperation.ConfirmPeerPushCredit,
{ {
peerPushPaymentIncomingId: checkResp.peerPushPaymentIncomingId, peerPushCreditId: checkResp.peerPushCreditId,
}, },
); );

12
packages/taler-util/src/wallet-types.ts
View File

@ -2438,7 +2438,7 @@ export interface PreparePeerPushCreditResponse {
amount: AmountString; amount: AmountString;
amountRaw: AmountString; amountRaw: AmountString;
amountEffective: AmountString; amountEffective: AmountString;
peerPushPaymentIncomingId: string; peerPushCreditId: string;
transactionId: string; transactionId: string;
} }
@ -2453,7 +2453,7 @@ export interface PreparePeerPullDebitResponse {
amountRaw: AmountString; amountRaw: AmountString;
amountEffective: AmountString; amountEffective: AmountString;
peerPullPaymentIncomingId: string; peerPullDebitId: string;
transactionId: string; transactionId: string;
} }
@ -2476,7 +2476,7 @@ export interface ConfirmPeerPushCreditRequest {
* *
* @deprecated specify transactionId instead! * @deprecated specify transactionId instead!
*/ */
peerPushPaymentIncomingId?: string; peerPushCreditId?: string;
transactionId?: string; transactionId?: string;
} }
@ -2491,7 +2491,7 @@ export interface AcceptPeerPullPaymentResponse {
export const codecForConfirmPeerPushPaymentRequest = export const codecForConfirmPeerPushPaymentRequest =
(): Codec<ConfirmPeerPushCreditRequest> => (): Codec<ConfirmPeerPushCreditRequest> =>
buildCodecForObject<ConfirmPeerPushCreditRequest>() buildCodecForObject<ConfirmPeerPushCreditRequest>()
.property("peerPushPaymentIncomingId", codecOptional(codecForString())) .property("peerPushCreditId", codecOptional(codecForString()))
.property("transactionId", codecOptional(codecForString())) .property("transactionId", codecOptional(codecForString()))
.build("ConfirmPeerPushCreditRequest"); .build("ConfirmPeerPushCreditRequest");
@ -2501,7 +2501,7 @@ export interface ConfirmPeerPullDebitRequest {
* *
* @deprecated use transactionId instead * @deprecated use transactionId instead
*/ */
peerPullPaymentIncomingId?: string; peerPullDebitId?: string;
transactionId?: string; transactionId?: string;
} }
@ -2519,7 +2519,7 @@ export const codecForApplyDevExperiment =
export const codecForAcceptPeerPullPaymentRequest = export const codecForAcceptPeerPullPaymentRequest =
(): Codec<ConfirmPeerPullDebitRequest> => (): Codec<ConfirmPeerPullDebitRequest> =>
buildCodecForObject<ConfirmPeerPullDebitRequest>() buildCodecForObject<ConfirmPeerPullDebitRequest>()
.property("peerPullPaymentIncomingId", codecOptional(codecForString())) .property("peerPullDebitId", codecOptional(codecForString()))
.property("transactionId", codecOptional(codecForString())) .property("transactionId", codecOptional(codecForString()))
.build("ConfirmPeerPullDebitRequest"); .build("ConfirmPeerPullDebitRequest");

12
packages/taler-wallet-cli/src/index.ts
View File

@ -1024,14 +1024,14 @@ peerCli
peerCli peerCli
.subcommand("confirmIncomingPayPull", "confirm-pull-debit") .subcommand("confirmIncomingPayPull", "confirm-pull-debit")
.requiredArgument("peerPullPaymentIncomingId", clk.STRING) .requiredArgument("peerPullDebitId", clk.STRING)
.action(async (args) => { .action(async (args) => {
await withWallet(args, async (wallet) => { await withWallet(args, async (wallet) => {
const resp = await wallet.client.call( const resp = await wallet.client.call(
WalletApiOperation.ConfirmPeerPullDebit, WalletApiOperation.ConfirmPeerPullDebit,
{ {
peerPullPaymentIncomingId: peerPullDebitId:
args.confirmIncomingPayPull.peerPullPaymentIncomingId, args.confirmIncomingPayPull.peerPullDebitId,
}, },
); );
console.log(JSON.stringify(resp, undefined, 2)); console.log(JSON.stringify(resp, undefined, 2));
@ -1040,14 +1040,14 @@ peerCli
peerCli peerCli
.subcommand("confirmIncomingPayPush", "confirm-push-credit") .subcommand("confirmIncomingPayPush", "confirm-push-credit")
.requiredArgument("peerPushPaymentIncomingId", clk.STRING) .requiredArgument("peerPushCreditId", clk.STRING)
.action(async (args) => { .action(async (args) => {
await withWallet(args, async (wallet) => { await withWallet(args, async (wallet) => {
const resp = await wallet.client.call( const resp = await wallet.client.call(
WalletApiOperation.ConfirmPeerPushCredit, WalletApiOperation.ConfirmPeerPushCredit,
{ {
peerPushPaymentIncomingId: peerPushCreditId:
args.confirmIncomingPayPush.peerPushPaymentIncomingId, args.confirmIncomingPayPush.peerPushCreditId,
}, },
); );
console.log(JSON.stringify(resp, undefined, 2)); console.log(JSON.stringify(resp, undefined, 2));

566
packages/taler-wallet-core/src/db.ts
View File

@ -60,7 +60,8 @@ import {
Logger, Logger,
CoinPublicKeyString, CoinPublicKeyString,
TalerPreciseTimestamp, TalerPreciseTimestamp,
j2s, codecForAny,
Codec,
} from "@gnu-taler/taler-util"; } from "@gnu-taler/taler-util";
import { import {
DbAccess, DbAccess,
@ -106,7 +107,7 @@ import { RetryInfo, TaskIdentifiers } from "./operations/common.js";
* for all previous versions must be written, which should be * for all previous versions must be written, which should be
* avoided. * avoided.
*/ */
export const TALER_WALLET_MAIN_DB_NAME = "taler-wallet-main-v9"; export const TALER_WALLET_MAIN_DB_NAME = "taler-wallet-main-v10";
/** /**
* Name of the metadata database. This database is used * Name of the metadata database. This database is used
@ -137,50 +138,26 @@ export const CURRENT_DB_CONFIG_KEY = "currentMainDbName";
* backwards-compatible way or object stores and indices * backwards-compatible way or object stores and indices
* are added. * are added.
*/ */
export const WALLET_DB_MINOR_VERSION = 10; export const WALLET_DB_MINOR_VERSION = 1;
/** /**
* Format of the operation status code: xyznnn * Format of the operation status code: 0x0abc_nnnn
*
* x=1: active
* yz=00: pending
* yz=02: dialog
* yz=03: aborting
* yz=10: suspended
* yz=13: suspended-aborting
* x=2: final
* yz=00: done
* yz=01: failed
* yz=02: expired
* yz=03: aborted
*/
// export const OperationStatusRange = {
// ActiveStart: 10000,
// ActiveEnd: 10999,
// SuspendedStart: 10999,
// SuspendedEnd: 10999,
// FinalStart: 20000,
// FinalEnd: 29999,
//} as const;
/** * a=1: active
* Ranges for operation status fields. * 0x0100_nnnn: pending
* * 0x0101_nnnn: dialog
* All individual enums should make sure that the values they * 0x0102_nnnn: (reserved)
* defined are in the right range. * 0x0103_nnnn: aborting
* 0x0110_nnnn: suspended
* 0x0113_nnnn: suspended-aborting
* a=5: final
* 0x0500_nnnn: done
* 0x0501_nnnn: failed
* 0x0502_nnnn: expired
* 0x0503_nnnn: aborted
*
* nnnn=0000 should always be the most generic minor state for the major state
*/ */
export enum OperationStatusRange {
// Operations that need to be actively processed.
ACTIVE_START = 10,
ACTIVE_END = 29,
// Operations that are suspended and might
// expire, but nothing else can be done.
SUSPENDED_START = 30,
SUSPENDED_END = 49,
// Operations that don't need any attention or processing.
DORMANT_START = 50,
DORMANT_END = 69,
}
/** /**
* Status of a withdrawal. * Status of a withdrawal.
@ -189,71 +166,70 @@ export enum WithdrawalGroupStatus {
/** /**
* Reserve must be registered with the bank. * Reserve must be registered with the bank.
*/ */
PendingRegisteringBank = 10, PendingRegisteringBank = 0x0100_0000,
SuspendedRegisteringBank = 0x0110_0000,
/** /**
* We've registered reserve's information with the bank * We've registered reserve's information with the bank
* and are now waiting for the user to confirm the withdraw * and are now waiting for the user to confirm the withdraw
* with the bank (typically 2nd factor auth). * with the bank (typically 2nd factor auth).
*/ */
PendingWaitConfirmBank = 11, PendingWaitConfirmBank = 0x0100_0001,
SuspendedWaitConfirmBank = 0x0110_0001,
/** /**
* Querying reserve status with the exchange. * Querying reserve status with the exchange.
*/ */
PendingQueryingStatus = 12, PendingQueryingStatus = 0x0100_0002,
SuspendedQueryingStatus = 0x0110_0002,
/** /**
* Ready for withdrawal. * Ready for withdrawal.
*/ */
PendingReady = 13, PendingReady = 0x0100_0003,
SuspendedReady = 0x0110_0003,
/** /**
* We are telling the bank that we don't want to complete * We are telling the bank that we don't want to complete
* the withdrawal! * the withdrawal!
*/ */
AbortingBank = 14, AbortingBank = 0x0103_0000,
SuspendedAbortingBank = 0x0113_0000,
/** /**
* Exchange wants KYC info from the user. * Exchange wants KYC info from the user.
*/ */
PendingKyc = 16, PendingKyc = 0x0100_0004,
SuspendedKyc = 0x0110_004,
/** /**
* Exchange is doing AML checks. * Exchange is doing AML checks.
*/ */
PendingAml = 17, PendingAml = 0x0100_0005,
SuspendedAml = 0x0100_0005,
SuspendedRegisteringBank = 30,
SuspendedWaitConfirmBank = 31,
SuspendedQueryingStatus = 32,
SuspendedReady = 33,
SuspendedAbortingBank = 34,
SuspendedKyc = 35,
SuspendedAml = 36,
/** /**
* The corresponding withdraw record has been created. * The corresponding withdraw record has been created.
* No further processing is done, unless explicitly requested * No further processing is done, unless explicitly requested
* by the user. * by the user.
*/ */
Finished = 50, Done = 0x0500_0000,
/** /**
* The bank aborted the withdrawal. * The bank aborted the withdrawal.
*/ */
FailedBankAborted = 51, FailedBankAborted = 0x0501_0000,
FailedAbortingBank = 59, FailedAbortingBank = 0x0501_0001,
/** /**
* Aborted in a state where we were supposed to * Aborted in a state where we were supposed to
* talk to the exchange. Money might have been * talk to the exchange. Money might have been
* wired or not. * wired or not.
*/ */
AbortedExchange = 60, AbortedExchange = 0x0503_0001,
AbortedBank = 61, AbortedBank = 0x0503_0002,
} }
/** /**
@ -298,17 +274,17 @@ export enum DenominationVerificationStatus {
/** /**
* Verification was delayed. * Verification was delayed.
*/ */
Unverified = OperationStatusRange.ACTIVE_START, Unverified = 0x0500_0000,
/** /**
* Verified as valid. * Verified as valid.
*/ */
VerifiedGood = OperationStatusRange.DORMANT_START, VerifiedGood = 0x0500_0000,
/** /**
* Verified as invalid. * Verified as invalid.
*/ */
VerifiedBad = OperationStatusRange.DORMANT_START + 1, VerifiedBad = 0x0501_0000,
} }
export interface DenomFees { export interface DenomFees {
@ -904,50 +880,42 @@ export interface RewardRecord {
} }
export enum RewardRecordStatus { export enum RewardRecordStatus {
PendingPickup = 10, PendingPickup = 0x0100_0000,
SuspendedPickup = 0x0110_0000,
SuspendidPickup = 20, DialogAccept = 0x0101_0000,
Done = 0x0500_0000,
DialogAccept = 30, Aborted = 0x0500_0000,
Done = 50,
Aborted = 51,
} }
export enum RefreshCoinStatus { export enum RefreshCoinStatus {
Pending = OperationStatusRange.ACTIVE_START, Pending = 0x0100_0000,
Finished = OperationStatusRange.DORMANT_START, Finished = 0x0500_0000,
/** /**
* The refresh for this coin has been frozen, because of a permanent error. * The refresh for this coin has been frozen, because of a permanent error.
* More info in lastErrorPerCoin. * More info in lastErrorPerCoin.
*/ */
Failed = OperationStatusRange.DORMANT_START + 1, Failed = 0x0501_000,
}
export enum OperationStatus {
Finished = OperationStatusRange.DORMANT_START,
Pending = OperationStatusRange.ACTIVE_START,
} }
export enum RefreshOperationStatus { export enum RefreshOperationStatus {
Pending = 10 /* ACTIVE_START */, Pending = 0x0100_0000,
Suspended = 20 /* DORMANT_START + 2 */, Suspended = 0x0110_0000,
Finished = 50 /* DORMANT_START */, Finished = 0x0500_000,
Failed = 51 /* DORMANT_START + 1 */, Failed = 0x0501_000,
} }
/** /**
* Status of a single element of a deposit group. * Status of a single element of a deposit group.
*/ */
export enum DepositElementStatus { export enum DepositElementStatus {
Unknown = 10, Unknown = 0x0100_0000,
Accepted = 20, Accepted = 0x0100_0001,
KycRequired = 30, KycRequired = 0x0100_0002,
Wired = 40, Wired = 0x0500_0000,
RefundSuccess = 50, RefundSuccess = 0x0503_0000,
RefundFailed = 51, RefundFailed = 0x0501_0000,
} }
/** /**
@ -962,9 +930,6 @@ export interface RefreshReasonDetails {
* Group of refresh operations. The refreshed coins do not * Group of refresh operations. The refreshed coins do not
* have to belong to the same exchange, but must have the same * have to belong to the same exchange, but must have the same
* currency. * currency.
*
* FIXME: Should include the currency as a top-level field,
* but we need to write a migration for that.
*/ */
export interface RefreshGroupRecord { export interface RefreshGroupRecord {
operationStatus: RefreshOperationStatus; operationStatus: RefreshOperationStatus;
@ -980,8 +945,6 @@ export interface RefreshGroupRecord {
/** /**
* Currency of this refresh group. * Currency of this refresh group.
*
* FIXME: Write a migration to add this to earlier DB versions.
*/ */
currency: string; currency: string;
@ -1116,81 +1079,84 @@ export enum PurchaseStatus {
/** /**
* Not downloaded yet. * Not downloaded yet.
*/ */
PendingDownloadingProposal = 10, PendingDownloadingProposal = 0x0100_0000,
SuspendedDownloadingProposal = 0x0110_0000,
/** /**
* The user has accepted the proposal. * The user has accepted the proposal.
*/ */
PendingPaying = 11, PendingPaying = 0x0100_0001,
SuspendedPaying = 0x0110_0001,
/** /**
* Currently in the process of aborting with a refund. * Currently in the process of aborting with a refund.
*/ */
AbortingWithRefund = 12, AbortingWithRefund = 0x0103_0000,
SuspendedAbortingWithRefund = 0x0113_0000,
/** /**
* Paying a second time, likely with different session ID * Paying a second time, likely with different session ID
*/ */
PendingPayingReplay = 13, PendingPayingReplay = 0x0100_0002,
SuspendedPayingReplay = 0x0110_0002,
/** /**
* Query for refunds (until query succeeds). * Query for refunds (until query succeeds).
*/ */
PendingQueryingRefund = 14, PendingQueryingRefund = 0x0100_0003,
SuspendedQueryingRefund = 0x0110_0003,
/** /**
* Query for refund (until auto-refund deadline is reached). * Query for refund (until auto-refund deadline is reached).
*/ */
PendingQueryingAutoRefund = 15, PendingQueryingAutoRefund = 0x0100_0004,
SuspendedQueryingAutoRefund = 0x0110_0004,
PendingAcceptRefund = 16, PendingAcceptRefund = 0x0100_0005,
SuspendedPendingAcceptRefund = 0x0100_0005,
SuspendedDownloadingProposal = 20,
SuspendedPaying = 21,
SuspendedAbortingWithRefund = 22,
SuspendedPayingReplay = 23,
SuspendedQueryingRefund = 24,
SuspendedQueryingAutoRefund = 25,
SuspendedPendingAcceptRefund = 26,
/** /**
* Proposal downloaded, but the user needs to accept/reject it. * Proposal downloaded, but the user needs to accept/reject it.
*/ */
DialogProposed = 30, DialogProposed = 0x0101_0000,
/** /**
* Proposal shared to other wallet or read from other wallet * Proposal shared to other wallet or read from other wallet
* the user needs to accept/reject it. * the user needs to accept/reject it.
*/ */
DialogShared = 31, DialogShared = 0x0101_0001,
/** /**
* The user has rejected the proposal. * The user has rejected the proposal.
*/ */
AbortedProposalRefused = 50, AbortedProposalRefused = 0x0503_0000,
/** /**
* Downloading or processing the proposal has failed permanently. * Downloading or processing the proposal has failed permanently.
*/ */
FailedClaim = 51, FailedClaim = 0x0501_0000,
/**
* Downloaded proposal was detected as a re-purchase.
*/
RepurchaseDetected = 52,
/**
* The payment has been aborted.
*/
AbortedIncompletePayment = 53,
/** /**
* Payment was successful. * Payment was successful.
*/ */
Done = 54, Done = 0x0500_0000,
FailedAbort = 55, /**
* Downloaded proposal was detected as a re-purchase.
*/
DoneRepurchaseDetected = 0x0500_0001,
AbortedRefunded = 56, /**
* The payment has been aborted.
*/
AbortedIncompletePayment = 0x0503_0000,
/**
* Tried to abort, but aborting failed or was cancelled.
*/
FailedAbort = 0x0501_0001,
AbortedRefunded = 0x0503_0000,
} }
/** /**
@ -1304,14 +1270,6 @@ export interface PurchaseRecord {
*/ */
timestampAccept: TalerPreciseTimestamp | undefined; timestampAccept: TalerPreciseTimestamp | undefined;
/**
* Pending refunds for the purchase. A refund is pending
* when the merchant reports a transient error from the exchange.
*
* FIXME: Put this into a separate object store?
*/
// refunds: { [refundKey: string]: WalletRefundItem };
/** /**
* When was the last refund made? * When was the last refund made?
* Set to 0 if no refund was made on the purchase. * Set to 0 if no refund was made on the purchase.
@ -1375,6 +1333,7 @@ export interface WalletBackupConfState {
lastBackupNonce?: string; lastBackupNonce?: string;
} }
// FIXME: Should these be numeric codes?
export const enum WithdrawalRecordType { export const enum WithdrawalRecordType {
BankManual = "bank-manual", BankManual = "bank-manual",
BankIntegrated = "bank-integrated", BankIntegrated = "bank-integrated",
@ -1684,19 +1643,21 @@ export interface BackupProviderRecord {
} }
export enum DepositOperationStatus { export enum DepositOperationStatus {
PendingDeposit = 10, PendingDeposit = 0x0100_0000,
Aborting = 11, PendingTrack = 0x0100_0001,
PendingTrack = 12, PendingKyc = 0x0100_0002,
PendingKyc = 13,
SuspendedDeposit = 20, Aborting = 0x0103_0000,
SuspendedAborting = 21,
SuspendedTrack = 22,
SuspendedKyc = 23,
Finished = 50, SuspendedDeposit = 0x0110_0000,
Failed = 51, SuspendedTrack = 0x0110_0001,
Aborted = 52, SuspendedKyc = 0x0110_0002,
SuspendedAborting = 0x0113_0000,
Finished = 0x0500_0000,
Failed = 0x0501_0000,
Aborted = 0x0503_0000,
} }
export interface DepositTrackingInfo { export interface DepositTrackingInfo {
@ -1787,31 +1748,6 @@ export interface DepositKycInfo {
exchangeBaseUrl: string; exchangeBaseUrl: string;
} }
/**
* Record for a deposits that the wallet observed
* as a result of double spending, but which is not
* present in the wallet's own database otherwise.
*/
export interface GhostDepositGroupRecord {
/**
* When multiple deposits for the same contract terms hash
* have a different timestamp, we choose the earliest one.
*/
timestamp: TalerPreciseTimestamp;
contractTermsHash: string;
deposits: {
coinPub: string;
amount: AmountString;
timestamp: TalerProtocolTimestamp;
depositFee: AmountString;
merchantPub: string;
coinSig: string;
wireHash: string;
}[];
}
export interface TombstoneRecord { export interface TombstoneRecord {
/** /**
* Tombstone ID, with the syntax "tmb:<type>:<key>". * Tombstone ID, with the syntax "tmb:<type>:<key>".
@ -1819,24 +1755,24 @@ export interface TombstoneRecord {
id: string; id: string;
} }
export enum PeerPushPaymentInitiationStatus { export enum PeerPushDebitStatus {
/** /**
* Initiated, but no purse created yet. * Initiated, but no purse created yet.
*/ */
PendingCreatePurse = 10 /* ACTIVE_START */, PendingCreatePurse = 0x0100_0000 /* ACTIVE_START */,
PendingReady = 11, PendingReady = 0x0100_0001,
AbortingDeletePurse = 12, AbortingDeletePurse = 0x0103_0000,
AbortingRefresh = 13, AbortingRefresh = 0x0103_0001,
SuspendedCreatePurse = 30, SuspendedCreatePurse = 0x0110_0000,
SuspendedReady = 31, SuspendedReady = 0x0110_0001,
SuspendedAbortingDeletePurse = 32, SuspendedAbortingDeletePurse = 0x0113_0000,
SuspendedAbortingRefresh = 33, SuspendedAbortingRefresh = 0x0113_0001,
Done = 50 /* DORMANT_START */, Done = 0x0500_0000,
Aborted = 51, Aborted = 0x0503_0000,
Failed = 52, Failed = 0x0501_0000,
Expired = 53, Expired = 0x0502_0000,
} }
export interface PeerPushPaymentCoinSelection { export interface PeerPushPaymentCoinSelection {
@ -1847,7 +1783,7 @@ export interface PeerPushPaymentCoinSelection {
/** /**
* Record for a push P2P payment that this wallet initiated. * Record for a push P2P payment that this wallet initiated.
*/ */
export interface PeerPushPaymentInitiationRecord { export interface PeerPushDebitRecord {
/** /**
* What exchange are funds coming from? * What exchange are funds coming from?
*/ */
@ -1907,32 +1843,34 @@ export interface PeerPushPaymentInitiationRecord {
/** /**
* Status of the peer push payment initiation. * Status of the peer push payment initiation.
*/ */
status: PeerPushPaymentInitiationStatus; status: PeerPushDebitStatus;
} }
export enum PeerPullPaymentInitiationStatus { export enum PeerPullPaymentCreditStatus {
PendingCreatePurse = 10 /* ACTIVE_START */, PendingCreatePurse = 0x0100_0000,
/** /**
* Purse created, waiting for the other party to accept the * Purse created, waiting for the other party to accept the
* invoice and deposit money into it. * invoice and deposit money into it.
*/ */
PendingReady = 11 /* ACTIVE_START + 1 */, PendingReady = 0x0100_0001,
PendingMergeKycRequired = 12 /* ACTIVE_START + 2 */, PendingMergeKycRequired = 0x0100_0002,
PendingWithdrawing = 13, PendingWithdrawing = 0x0100_0003,
AbortingDeletePurse = 14,
SuspendedCreatePurse = 30, AbortingDeletePurse = 0x0103_0000,
SuspendedReady = 31,
SuspendedMergeKycRequired = 32,
SuspendedWithdrawing = 33,
SuspendedAbortingDeletePurse = 34,
Done = 50 /* DORMANT_START */, SuspendedCreatePurse = 0x0110_0000,
Failed = 51, SuspendedReady = 0x0110_0001,
Aborted = 52, SuspendedMergeKycRequired = 0x0110_0002,
SuspendedWithdrawing = 0x0113_0000,
SuspendedAbortingDeletePurse = 0x0113_0000,
Done = 0x0500_0000,
Failed = 0x0501_0000,
Aborted = 0x0503_0000,
} }
export interface PeerPullPaymentInitiationRecord { export interface PeerPullCreditRecord {
/** /**
* What exchange are we using for the payment request? * What exchange are we using for the payment request?
*/ */
@ -1982,7 +1920,7 @@ export interface PeerPullPaymentInitiationRecord {
/** /**
* Status of the peer pull payment initiation. * Status of the peer pull payment initiation.
*/ */
status: PeerPullPaymentInitiationStatus; status: PeerPullPaymentCreditStatus;
kycInfo?: KycPendingInfo; kycInfo?: KycPendingInfo;
@ -1991,24 +1929,24 @@ export interface PeerPullPaymentInitiationRecord {
withdrawalGroupId: string | undefined; withdrawalGroupId: string | undefined;
} }
export enum PeerPushPaymentIncomingStatus { export enum PeerPushCreditStatus {
PendingMerge = 10 /* ACTIVE_START */, PendingMerge = 0x0100_0000,
PendingMergeKycRequired = 11 /* ACTIVE_START + 1 */, PendingMergeKycRequired = 0x0100_0001,
/** /**
* Merge was successful and withdrawal group has been created, now * Merge was successful and withdrawal group has been created, now
* everything is in the hand of the withdrawal group. * everything is in the hand of the withdrawal group.
*/ */
PendingWithdrawing = 12, PendingWithdrawing = 0x0100_0002,
SuspendedMerge = 20, SuspendedMerge = 0x0110_0000,
SuspendedMergeKycRequired = 21, SuspendedMergeKycRequired = 0x0110_0001,
SuspendedWithdrawing = 22, SuspendedWithdrawing = 0x0110_0002,
DialogProposed = 30 /* USER_ATTENTION_START */, DialogProposed = 0x0101_0000,
Done = 50 /* DORMANT_START */, Done = 0x0500_0000,
Aborted = 51, Aborted = 0x0503_0000,
Failed = 52, Failed = 0x0501_0000,
} }
/** /**
@ -2017,7 +1955,7 @@ export enum PeerPushPaymentIncomingStatus {
* Unique: (exchangeBaseUrl, pursePub) * Unique: (exchangeBaseUrl, pursePub)
*/ */
export interface PeerPushPaymentIncomingRecord { export interface PeerPushPaymentIncomingRecord {
peerPushPaymentIncomingId: string; peerPushCreditId: string;
exchangeBaseUrl: string; exchangeBaseUrl: string;
@ -2040,7 +1978,7 @@ export interface PeerPushPaymentIncomingRecord {
/** /**
* Status of the peer push payment incoming initiation. * Status of the peer push payment incoming initiation.
*/ */
status: PeerPushPaymentIncomingStatus; status: PeerPushCreditStatus;
/** /**
* Associated withdrawal group. * Associated withdrawal group.
@ -2061,17 +1999,17 @@ export interface PeerPushPaymentIncomingRecord {
} }
export enum PeerPullDebitRecordStatus { export enum PeerPullDebitRecordStatus {
PendingDeposit = 10 /* ACTIVE_START */, PendingDeposit = 0x0100_0001,
AbortingRefresh = 11, AbortingRefresh = 0x0103_0001,
SuspendedDeposit = 20, SuspendedDeposit = 0x0110_0001,
SuspendedAbortingRefresh = 21, SuspendedAbortingRefresh = 0x0113_0001,
DialogProposed = 30 /* USER_ATTENTION_START */, DialogProposed = 0x0101_0001,
DonePaid = 50 /* DORMANT_START */, Done = 0x0500_0000,
Aborted = 51, Aborted = 0x0503_0000,
Failed = 52, Failed = 0x0501_0000,
} }
export interface PeerPullPaymentCoinSelection { export interface PeerPullPaymentCoinSelection {
@ -2089,7 +2027,7 @@ export interface PeerPullPaymentCoinSelection {
* AKA PeerPullDebit. * AKA PeerPullDebit.
*/ */
export interface PeerPullPaymentIncomingRecord { export interface PeerPullPaymentIncomingRecord {
peerPullPaymentIncomingId: string; peerPullDebitId: string;
pursePub: string; pursePub: string;
@ -2234,10 +2172,10 @@ export interface CurrencySettingsRecord {
} }
export enum RefundGroupStatus { export enum RefundGroupStatus {
Pending = 10, Pending = 0x0100_0000,
Done = 50, Done = 0x0500_0000,
Failed = 51, Failed = 0x0501_0000,
Aborted = 52, Aborted = 0x0503_0000,
} }
/** /**
@ -2273,16 +2211,16 @@ export enum RefundItemStatus {
* *
* We'll try again! * We'll try again!
*/ */
Pending = 10, Pending = 0x0100_0000,
/** /**
* Refund was obtained successfully. * Refund was obtained successfully.
*/ */
Done = 50, Done = 0x0500_0000,
/** /**
* Permanent error reported by the exchange * Permanent error reported by the exchange
* for the refund. * for the refund.
*/ */
Failed = 51, Failed = 0x0501_0000,
} }
/** /**
@ -2298,7 +2236,9 @@ export interface RefundItemRecord {
refundGroupId: string; refundGroupId: string;
// Execution time as claimed by the merchant /**
* Execution time as claimed by the merchant
*/
executionTime: TalerProtocolTimestamp; executionTime: TalerProtocolTimestamp;
/** /**
@ -2308,22 +2248,15 @@ export interface RefundItemRecord {
refundAmount: AmountString; refundAmount: AmountString;
//refundFee: AmountString;
/**
* Upper bound on the refresh cost incurred by
* applying this refund.
*
* Might be lower in practice when two refunds on the same
* coin are refreshed in the same refresh operation.
*/
//totalRefreshCostBound: AmountString;
coinPub: string; coinPub: string;
rtxid: number; rtxid: number;
} }
export function passthroughCodec<T>(): Codec<T> {
return codecForAny();
}
/** /**
* Schema definition for the IndexedDB * Schema definition for the IndexedDB
* wallet database. * wallet database.
@ -2333,7 +2266,6 @@ export const WalletStoresV1 = {
"currencySettings", "currencySettings",
describeContents<CurrencySettingsRecord>({ describeContents<CurrencySettingsRecord>({
keyPath: ["currency"], keyPath: ["currency"],
versionAdded: 3,
}), }),
{}, {},
), ),
@ -2542,17 +2474,10 @@ export const WalletStoresV1 = {
}), }),
{}, {},
), ),
ghostDepositGroups: describeStore( peerPushCredit: describeStore(
"ghostDepositGroups", "peerPushCredit",
describeContents<GhostDepositGroupRecord>({
keyPath: "contractTermsHash",
}),
{},
),
peerPushPaymentIncoming: describeStore(
"peerPushPaymentIncoming",
describeContents<PeerPushPaymentIncomingRecord>({ describeContents<PeerPushPaymentIncomingRecord>({
keyPath: "peerPushPaymentIncomingId", keyPath: "peerPushCreditId",
}), }),
{ {
byExchangeAndPurse: describeIndex("byExchangeAndPurse", [ byExchangeAndPurse: describeIndex("byExchangeAndPurse", [
@ -2563,24 +2488,21 @@ export const WalletStoresV1 = {
"byExchangeAndContractPriv", "byExchangeAndContractPriv",
["exchangeBaseUrl", "contractPriv"], ["exchangeBaseUrl", "contractPriv"],
{ {
versionAdded: 5,
unique: true, unique: true,
}, },
), ),
byWithdrawalGroupId: describeIndex( byWithdrawalGroupId: describeIndex(
"byWithdrawalGroupId", "byWithdrawalGroupId",
"withdrawalGroupId", "withdrawalGroupId",
{ {},
versionAdded: 5,
},
), ),
byStatus: describeIndex("byStatus", "status"), byStatus: describeIndex("byStatus", "status"),
}, },
), ),
peerPullPaymentIncoming: describeStore( peerPullDebit: describeStore(
"peerPullPaymentIncoming", "peerPullDebit",
describeContents<PeerPullPaymentIncomingRecord>({ describeContents<PeerPullPaymentIncomingRecord>({
keyPath: "peerPullPaymentIncomingId", keyPath: "peerPullDebitId",
}), }),
{ {
byExchangeAndPurse: describeIndex("byExchangeAndPurse", [ byExchangeAndPurse: describeIndex("byExchangeAndPurse", [
@ -2591,16 +2513,15 @@ export const WalletStoresV1 = {
"byExchangeAndContractPriv", "byExchangeAndContractPriv",
["exchangeBaseUrl", "contractPriv"], ["exchangeBaseUrl", "contractPriv"],
{ {
versionAdded: 5,
unique: true, unique: true,
}, },
), ),
byStatus: describeIndex("byStatus", "status"), byStatus: describeIndex("byStatus", "status"),
}, },
), ),
peerPullPaymentInitiations: describeStore( peerPullCredit: describeStore(
"peerPullPaymentInitiations", "peerPullCredit",
describeContents<PeerPullPaymentInitiationRecord>({ describeContents<PeerPullCreditRecord>({
keyPath: "pursePub", keyPath: "pursePub",
}), }),
{ {
@ -2609,14 +2530,13 @@ export const WalletStoresV1 = {
"byWithdrawalGroupId", "byWithdrawalGroupId",
"withdrawalGroupId", "withdrawalGroupId",
{ {
versionAdded: 5,
}, },
), ),
}, },
), ),
peerPushPaymentInitiations: describeStore( peerPushDebit: describeStore(
"peerPushPaymentInitiations", "peerPushDebit",
describeContents<PeerPushPaymentInitiationRecord>({ describeContents<PeerPushDebitRecord>({
keyPath: "pursePub", keyPath: "pursePub",
}), }),
{ {
@ -2641,7 +2561,6 @@ export const WalletStoresV1 = {
"userAttention", "userAttention",
describeContents<UserAttentionRecord>({ describeContents<UserAttentionRecord>({
keyPath: ["entityId", "info.type"], keyPath: ["entityId", "info.type"],
versionAdded: 2,
}), }),
{}, {},
), ),
@ -2649,12 +2568,10 @@ export const WalletStoresV1 = {
"refundGroups", "refundGroups",
describeContents<RefundGroupRecord>({ describeContents<RefundGroupRecord>({
keyPath: "refundGroupId", keyPath: "refundGroupId",
versionAdded: 7,
}), }),
{ {
byProposalId: describeIndex("byProposalId", "proposalId"), byProposalId: describeIndex("byProposalId", "proposalId"),
byStatus: describeIndex("byStatus", "status", { byStatus: describeIndex("byStatus", "status", {
versionAdded: 10,
}), }),
}, },
), ),
@ -2662,7 +2579,6 @@ export const WalletStoresV1 = {
"refundItems", "refundItems",
describeContents<RefundItemRecord>({ describeContents<RefundItemRecord>({
keyPath: "id", keyPath: "id",
versionAdded: 7,
autoIncrement: true, autoIncrement: true,
}), }),
{ {
@ -2677,7 +2593,6 @@ export const WalletStoresV1 = {
"fixups", "fixups",
describeContents<FixupRecord>({ describeContents<FixupRecord>({
keyPath: "fixupName", keyPath: "fixupName",
versionAdded: 2,
}), }),
{}, {},
), ),
@ -2905,106 +2820,7 @@ export interface FixupDescription {
/** /**
* Manual migrations between minor versions of the DB schema. * Manual migrations between minor versions of the DB schema.
*/ */
export const walletDbFixups: FixupDescription[] = [ export const walletDbFixups: FixupDescription[] = [];
{
name: "RefreshGroupRecord_currency",
async fn(tx): Promise<void> {
await tx.refreshGroups.iter().forEachAsync(async (rg) => {
if (rg.currency) {
return;
}
// Empty refresh group without input coin, delete it!
if (rg.inputPerCoin.length === 0) {
await tx.refreshGroups.delete(rg.refreshGroupId);
return;
}
rg.currency = Amounts.parseOrThrow(rg.inputPerCoin[0]).currency;
await tx.refreshGroups.put(rg);
});
},
},
{
name: "DepositGroupRecord_transactionPerCoin",
async fn(tx): Promise<void> {
await tx.depositGroups.iter().forEachAsync(async (dg) => {
if (dg.transactionPerCoin) {
return;
}
dg.transactionPerCoin = dg.depositedPerCoin.map(
(c) => DepositElementStatus.Unknown,
);
await tx.depositGroups.put(dg);
});
},
},
{
name: "PeerPullPaymentIncomingRecord_totalCostEstimated_add",
async fn(tx): Promise<void> {
await tx.peerPullPaymentIncoming.iter().forEachAsync(async (pi) => {
if (pi.totalCostEstimated) {
return;
}
// Not really the cost, but a good substitute for older transactions
// that don't sture the effective cost of the transaction.
pi.totalCostEstimated = pi.contractTerms.amount;
await tx.peerPullPaymentIncoming.put(pi);
});
},
},
{
name: "PeerPushPaymentIncomingRecord_totalCostEstimated_add",
async fn(tx): Promise<void> {
await tx.peerPushPaymentIncoming.iter().forEachAsync(async (pi) => {
if (pi.estimatedAmountEffective) {
return;
}
const contractTerms = await tx.contractTerms.get(pi.contractTermsHash);
if (!contractTerms) {
// Not sure what we can do here!
} else {
// Not really the cost, but a good substitute for older transactions
// that don't sture the effective cost of the transaction.
pi.estimatedAmountEffective = contractTerms.contractTermsRaw.amount;
await tx.peerPushPaymentIncoming.put(pi);
}
});
},
},
{
name: "PeerPullPaymentInitiationRecord_estimatedAmountEffective_add",
async fn(tx): Promise<void> {
await tx.peerPullPaymentInitiations.iter().forEachAsync(async (pi) => {
if (pi.estimatedAmountEffective) {
return;
}
pi.estimatedAmountEffective = pi.amount;
await tx.peerPullPaymentInitiations.put(pi);
});
},
},
{
name: "PeerPushPaymentInitiationRecord_ALL_removeLegacyTx",
async fn(tx): Promise<void> {
await tx.peerPushPaymentInitiations.iter().forEachAsync(async (pi) => {
// Remove legacy transactions that don't have the totalCost field yet.
if (!pi.totalCost) {
await tx.peerPushPaymentInitiations.delete(pi.pursePub);
}
});
},
},
{
name: "CoinAvailabilityRecord_visibleCoinCount_add",
async fn(tx): Promise<void> {
await tx.coinAvailability.iter().forEachAsync(async (r) => {
if (r.visibleCoinCount == null) {
r.visibleCoinCount = r.freshCoinCount;
await tx.coinAvailability.put(r);
}
});
},
},
];
const logger = new Logger("db.ts"); const logger = new Logger("db.ts");

2
packages/taler-wallet-core/src/operations/balance.ts
View File

@ -163,7 +163,7 @@ export async function getBalancesInsideTransaction(
case WithdrawalGroupStatus.AbortedExchange: case WithdrawalGroupStatus.AbortedExchange:
case WithdrawalGroupStatus.FailedAbortingBank: case WithdrawalGroupStatus.FailedAbortingBank:
case WithdrawalGroupStatus.FailedBankAborted: case WithdrawalGroupStatus.FailedBankAborted:
case WithdrawalGroupStatus.Finished: case WithdrawalGroupStatus.Done:
// Does not count as pendingIncoming // Does not count as pendingIncoming
return; return;
case WithdrawalGroupStatus.PendingReady: case WithdrawalGroupStatus.PendingReady:

28
packages/taler-wallet-core/src/operations/common.ts
View File

@ -52,9 +52,9 @@ import {
BackupProviderRecord, BackupProviderRecord,
DepositGroupRecord, DepositGroupRecord,
PeerPullPaymentIncomingRecord, PeerPullPaymentIncomingRecord,
PeerPullPaymentInitiationRecord, PeerPullCreditRecord,
PeerPushPaymentIncomingRecord, PeerPushPaymentIncomingRecord,
PeerPushPaymentInitiationRecord, PeerPushDebitRecord,
PurchaseRecord, PurchaseRecord,
RecoupGroupRecord, RecoupGroupRecord,
RefreshGroupRecord, RefreshGroupRecord,
@ -271,7 +271,7 @@ function convertTaskToTransactionId(
case PendingTaskType.PeerPullDebit: case PendingTaskType.PeerPullDebit:
return constructTransactionIdentifier({ return constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId: parsedTaskId.peerPullPaymentIncomingId, peerPullDebitId: parsedTaskId.peerPullDebitId,
}); });
// FIXME: This doesn't distinguish internal-withdrawal. // FIXME: This doesn't distinguish internal-withdrawal.
// Maybe we should have a different task type for that as well? // Maybe we should have a different task type for that as well?
@ -284,7 +284,7 @@ function convertTaskToTransactionId(
case PendingTaskType.PeerPushCredit: case PendingTaskType.PeerPushCredit:
return constructTransactionIdentifier({ return constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId: parsedTaskId.peerPushPaymentIncomingId, peerPushCreditId: parsedTaskId.peerPushCreditId,
}); });
case PendingTaskType.Deposit: case PendingTaskType.Deposit:
return constructTransactionIdentifier({ return constructTransactionIdentifier({
@ -836,9 +836,9 @@ export type ParsedTaskIdentifier =
| { tag: PendingTaskType.Deposit; depositGroupId: string } | { tag: PendingTaskType.Deposit; depositGroupId: string }
| { tag: PendingTaskType.ExchangeCheckRefresh; exchangeBaseUrl: string } | { tag: PendingTaskType.ExchangeCheckRefresh; exchangeBaseUrl: string }
| { tag: PendingTaskType.ExchangeUpdate; exchangeBaseUrl: string } | { tag: PendingTaskType.ExchangeUpdate; exchangeBaseUrl: string }
| { tag: PendingTaskType.PeerPullDebit; peerPullPaymentIncomingId: string } | { tag: PendingTaskType.PeerPullDebit; peerPullDebitId: string }
| { tag: PendingTaskType.PeerPullCredit; pursePub: string } | { tag: PendingTaskType.PeerPullCredit; pursePub: string }
| { tag: PendingTaskType.PeerPushCredit; peerPushPaymentIncomingId: string } | { tag: PendingTaskType.PeerPushCredit; peerPushCreditId: string }
| { tag: PendingTaskType.PeerPushDebit; pursePub: string } | { tag: PendingTaskType.PeerPushDebit; pursePub: string }
| { tag: PendingTaskType.Purchase; proposalId: string } | { tag: PendingTaskType.Purchase; proposalId: string }
| { tag: PendingTaskType.Recoup; recoupGroupId: string } | { tag: PendingTaskType.Recoup; recoupGroupId: string }
@ -865,9 +865,9 @@ export function parseTaskIdentifier(x: string): ParsedTaskIdentifier {
case PendingTaskType.PeerPullCredit: case PendingTaskType.PeerPullCredit:
return { tag: type, pursePub: rest[0] }; return { tag: type, pursePub: rest[0] };
case PendingTaskType.PeerPullDebit: case PendingTaskType.PeerPullDebit:
return { tag: type, peerPullPaymentIncomingId: rest[0] }; return { tag: type, peerPullDebitId: rest[0] };
case PendingTaskType.PeerPushCredit: case PendingTaskType.PeerPushCredit:
return { tag: type, peerPushPaymentIncomingId: rest[0] }; return { tag: type, peerPushCreditId: rest[0] };
case PendingTaskType.PeerPushDebit: case PendingTaskType.PeerPushDebit:
return { tag: type, pursePub: rest[0] }; return { tag: type, pursePub: rest[0] };
case PendingTaskType.Purchase: case PendingTaskType.Purchase:
@ -896,9 +896,9 @@ export function constructTaskIdentifier(p: ParsedTaskIdentifier): TaskId {
case PendingTaskType.ExchangeUpdate: case PendingTaskType.ExchangeUpdate:
return `${p.tag}:${p.exchangeBaseUrl}` as TaskId; return `${p.tag}:${p.exchangeBaseUrl}` as TaskId;
case PendingTaskType.PeerPullDebit: case PendingTaskType.PeerPullDebit:
return `${p.tag}:${p.peerPullPaymentIncomingId}` as TaskId; return `${p.tag}:${p.peerPullDebitId}` as TaskId;
case PendingTaskType.PeerPushCredit: case PendingTaskType.PeerPushCredit:
return `${p.tag}:${p.peerPushPaymentIncomingId}` as TaskId; return `${p.tag}:${p.peerPushCreditId}` as TaskId;
case PendingTaskType.PeerPullCredit: case PendingTaskType.PeerPullCredit:
return `${p.tag}:${p.pursePub}` as TaskId; return `${p.tag}:${p.pursePub}` as TaskId;
case PendingTaskType.PeerPushDebit: case PendingTaskType.PeerPushDebit:
@ -950,23 +950,23 @@ export namespace TaskIdentifiers {
return `${PendingTaskType.Backup}:${backupRecord.baseUrl}` as TaskId; return `${PendingTaskType.Backup}:${backupRecord.baseUrl}` as TaskId;
} }
export function forPeerPushPaymentInitiation( export function forPeerPushPaymentInitiation(
ppi: PeerPushPaymentInitiationRecord, ppi: PeerPushDebitRecord,
): TaskId { ): TaskId {
return `${PendingTaskType.PeerPushDebit}:${ppi.pursePub}` as TaskId; return `${PendingTaskType.PeerPushDebit}:${ppi.pursePub}` as TaskId;
} }
export function forPeerPullPaymentInitiation( export function forPeerPullPaymentInitiation(
ppi: PeerPullPaymentInitiationRecord, ppi: PeerPullCreditRecord,
): TaskId { ): TaskId {
return `${PendingTaskType.PeerPullCredit}:${ppi.pursePub}` as TaskId; return `${PendingTaskType.PeerPullCredit}:${ppi.pursePub}` as TaskId;
} }
export function forPeerPullPaymentDebit( export function forPeerPullPaymentDebit(
ppi: PeerPullPaymentIncomingRecord, ppi: PeerPullPaymentIncomingRecord,
): TaskId { ): TaskId {
return `${PendingTaskType.PeerPullDebit}:${ppi.peerPullPaymentIncomingId}` as TaskId; return `${PendingTaskType.PeerPullDebit}:${ppi.peerPullDebitId}` as TaskId;
} }
export function forPeerPushCredit( export function forPeerPushCredit(
ppi: PeerPushPaymentIncomingRecord, ppi: PeerPushPaymentIncomingRecord,
): TaskId { ): TaskId {
return `${PendingTaskType.PeerPushCredit}:${ppi.peerPushPaymentIncomingId}` as TaskId; return `${PendingTaskType.PeerPushCredit}:${ppi.peerPushCreditId}` as TaskId;
} }
} }

10
packages/taler-wallet-core/src/operations/pay-merchant.ts
View File

@ -541,7 +541,7 @@ async function processDownloadProposal(
// if original order is refunded. // if original order is refunded.
if (otherPurchase && otherPurchase.refundAmountAwaiting === undefined) { if (otherPurchase && otherPurchase.refundAmountAwaiting === undefined) {
logger.warn("repurchase detected"); logger.warn("repurchase detected");
p.purchaseStatus = PurchaseStatus.RepurchaseDetected; p.purchaseStatus = PurchaseStatus.DoneRepurchaseDetected;
p.repurchaseProposalId = otherPurchase.proposalId; p.repurchaseProposalId = otherPurchase.proposalId;
await tx.purchases.put(p); await tx.purchases.put(p);
} else { } else {
@ -974,7 +974,7 @@ export async function checkPaymentByProposalId(
if (!proposal) { if (!proposal) {
throw Error(`could not get proposal ${proposalId}`); throw Error(`could not get proposal ${proposalId}`);
} }
if (proposal.purchaseStatus === PurchaseStatus.RepurchaseDetected) { if (proposal.purchaseStatus === PurchaseStatus.DoneRepurchaseDetected) {
const existingProposalId = proposal.repurchaseProposalId; const existingProposalId = proposal.repurchaseProposalId;
if (existingProposalId) { if (existingProposalId) {
logger.trace("using existing purchase for same product"); logger.trace("using existing purchase for same product");
@ -1527,7 +1527,7 @@ export async function processPurchase(
return processPurchaseDialogShared(ws, purchase); return processPurchaseDialogShared(ws, purchase);
case PurchaseStatus.FailedClaim: case PurchaseStatus.FailedClaim:
case PurchaseStatus.Done: case PurchaseStatus.Done:
case PurchaseStatus.RepurchaseDetected: case PurchaseStatus.DoneRepurchaseDetected:
case PurchaseStatus.DialogProposed: case PurchaseStatus.DialogProposed:
case PurchaseStatus.AbortedProposalRefused: case PurchaseStatus.AbortedProposalRefused:
case PurchaseStatus.AbortedIncompletePayment: case PurchaseStatus.AbortedIncompletePayment:
@ -2099,7 +2099,7 @@ export function computePayMerchantTransactionState(
return { return {
major: TransactionMajorState.Done, major: TransactionMajorState.Done,
}; };
case PurchaseStatus.RepurchaseDetected: case PurchaseStatus.DoneRepurchaseDetected:
return { return {
major: TransactionMajorState.Failed, major: TransactionMajorState.Failed,
minor: TransactionMinorState.Repurchase, minor: TransactionMinorState.Repurchase,
@ -2176,7 +2176,7 @@ export function computePayMerchantTransactionActions(
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PurchaseStatus.Done: case PurchaseStatus.Done:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PurchaseStatus.RepurchaseDetected: case PurchaseStatus.DoneRepurchaseDetected:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PurchaseStatus.AbortedIncompletePayment: case PurchaseStatus.AbortedIncompletePayment:
return [TransactionAction.Delete]; return [TransactionAction.Delete];

328
packages/taler-wallet-core/src/operations/pay-peer-pull-credit.ts
View File

@ -55,8 +55,8 @@ import {
import { import {
KycPendingInfo, KycPendingInfo,
KycUserType, KycUserType,
PeerPullPaymentInitiationRecord, PeerPullCreditRecord,
PeerPullPaymentInitiationStatus, PeerPullPaymentCreditStatus,
WithdrawalGroupStatus, WithdrawalGroupStatus,
WithdrawalRecordType, WithdrawalRecordType,
updateExchangeFromUrl, updateExchangeFromUrl,
@ -90,7 +90,7 @@ const logger = new Logger("pay-peer-pull-credit.ts");
async function queryPurseForPeerPullCredit( async function queryPurseForPeerPullCredit(
ws: InternalWalletState, ws: InternalWalletState,
pullIni: PeerPullPaymentInitiationRecord, pullIni: PeerPullCreditRecord,
cancellationToken: CancellationToken, cancellationToken: CancellationToken,
): Promise<LongpollResult> { ): Promise<LongpollResult> {
const purseDepositUrl = new URL( const purseDepositUrl = new URL(
@ -159,18 +159,18 @@ async function queryPurseForPeerPullCredit(
pursePub: pullIni.pursePub, pursePub: pullIni.pursePub,
}); });
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations]) .mktx((x) => [x.peerPullCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const finPi = await tx.peerPullPaymentInitiations.get(pullIni.pursePub); const finPi = await tx.peerPullCredit.get(pullIni.pursePub);
if (!finPi) { if (!finPi) {
logger.warn("peerPullPaymentInitiation not found anymore"); logger.warn("peerPullCredit not found anymore");
return; return;
} }
const oldTxState = computePeerPullCreditTransactionState(finPi); const oldTxState = computePeerPullCreditTransactionState(finPi);
if (finPi.status === PeerPullPaymentInitiationStatus.PendingReady) { if (finPi.status === PeerPullPaymentCreditStatus.PendingReady) {
finPi.status = PeerPullPaymentInitiationStatus.PendingWithdrawing; finPi.status = PeerPullPaymentCreditStatus.PendingWithdrawing;
} }
await tx.peerPullPaymentInitiations.put(finPi); await tx.peerPullCredit.put(finPi);
const newTxState = computePeerPullCreditTransactionState(finPi); const newTxState = computePeerPullCreditTransactionState(finPi);
return { oldTxState, newTxState }; return { oldTxState, newTxState };
}); });
@ -214,22 +214,22 @@ async function longpollKycStatus(
kycStatusRes.status === HttpStatusCode.NoContent kycStatusRes.status === HttpStatusCode.NoContent
) { ) {
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations]) .mktx((x) => [x.peerPullCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const peerIni = await tx.peerPullPaymentInitiations.get(pursePub); const peerIni = await tx.peerPullCredit.get(pursePub);
if (!peerIni) { if (!peerIni) {
return; return;
} }
if ( if (
peerIni.status !== peerIni.status !==
PeerPullPaymentInitiationStatus.PendingMergeKycRequired PeerPullPaymentCreditStatus.PendingMergeKycRequired
) { ) {
return; return;
} }
const oldTxState = computePeerPullCreditTransactionState(peerIni); const oldTxState = computePeerPullCreditTransactionState(peerIni);
peerIni.status = PeerPullPaymentInitiationStatus.PendingCreatePurse; peerIni.status = PeerPullPaymentCreditStatus.PendingCreatePurse;
const newTxState = computePeerPullCreditTransactionState(peerIni); const newTxState = computePeerPullCreditTransactionState(peerIni);
await tx.peerPullPaymentInitiations.put(peerIni); await tx.peerPullCredit.put(peerIni);
return { oldTxState, newTxState }; return { oldTxState, newTxState };
}); });
notifyTransition(ws, transactionId, transitionInfo); notifyTransition(ws, transactionId, transitionInfo);
@ -250,7 +250,7 @@ async function longpollKycStatus(
async function processPeerPullCreditAbortingDeletePurse( async function processPeerPullCreditAbortingDeletePurse(
ws: InternalWalletState, ws: InternalWalletState,
peerPullIni: PeerPullPaymentInitiationRecord, peerPullIni: PeerPullCreditRecord,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const { pursePub, pursePriv } = peerPullIni; const { pursePub, pursePriv } = peerPullIni;
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
@ -272,24 +272,24 @@ async function processPeerPullCreditAbortingDeletePurse(
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [ .mktx((x) => [
x.peerPullPaymentInitiations, x.peerPullCredit,
x.refreshGroups, x.refreshGroups,
x.denominations, x.denominations,
x.coinAvailability, x.coinAvailability,
x.coins, x.coins,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const ppiRec = await tx.peerPullPaymentInitiations.get(pursePub); const ppiRec = await tx.peerPullCredit.get(pursePub);
if (!ppiRec) { if (!ppiRec) {
return undefined; return undefined;
} }
if ( if (
ppiRec.status !== PeerPullPaymentInitiationStatus.AbortingDeletePurse ppiRec.status !== PeerPullPaymentCreditStatus.AbortingDeletePurse
) { ) {
return undefined; return undefined;
} }
const oldTxState = computePeerPullCreditTransactionState(ppiRec); const oldTxState = computePeerPullCreditTransactionState(ppiRec);
ppiRec.status = PeerPullPaymentInitiationStatus.Aborted; ppiRec.status = PeerPullPaymentCreditStatus.Aborted;
const newTxState = computePeerPullCreditTransactionState(ppiRec); const newTxState = computePeerPullCreditTransactionState(ppiRec);
return { return {
oldTxState, oldTxState,
@ -303,7 +303,7 @@ async function processPeerPullCreditAbortingDeletePurse(
async function handlePeerPullCreditWithdrawing( async function handlePeerPullCreditWithdrawing(
ws: InternalWalletState, ws: InternalWalletState,
pullIni: PeerPullPaymentInitiationRecord, pullIni: PeerPullCreditRecord,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
if (!pullIni.withdrawalGroupId) { if (!pullIni.withdrawalGroupId) {
throw Error("invalid db state (withdrawing, but no withdrawal group ID"); throw Error("invalid db state (withdrawing, but no withdrawal group ID");
@ -315,14 +315,14 @@ async function handlePeerPullCreditWithdrawing(
const wgId = pullIni.withdrawalGroupId; const wgId = pullIni.withdrawalGroupId;
let finished: boolean = false; let finished: boolean = false;
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations, x.withdrawalGroups]) .mktx((x) => [x.peerPullCredit, x.withdrawalGroups])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const ppi = await tx.peerPullPaymentInitiations.get(pullIni.pursePub); const ppi = await tx.peerPullCredit.get(pullIni.pursePub);
if (!ppi) { if (!ppi) {
finished = true; finished = true;
return; return;
} }
if (ppi.status !== PeerPullPaymentInitiationStatus.PendingWithdrawing) { if (ppi.status !== PeerPullPaymentCreditStatus.PendingWithdrawing) {
finished = true; finished = true;
return; return;
} }
@ -333,13 +333,13 @@ async function handlePeerPullCreditWithdrawing(
return undefined; return undefined;
} }
switch (wg.status) { switch (wg.status) {
case WithdrawalGroupStatus.Finished: case WithdrawalGroupStatus.Done:
finished = true; finished = true;
ppi.status = PeerPullPaymentInitiationStatus.Done; ppi.status = PeerPullPaymentCreditStatus.Done;
break; break;
// FIXME: Also handle other final states! // FIXME: Also handle other final states!
} }
await tx.peerPullPaymentInitiations.put(ppi); await tx.peerPullCredit.put(ppi);
const newTxState = computePeerPullCreditTransactionState(ppi); const newTxState = computePeerPullCreditTransactionState(ppi);
return { return {
oldTxState, oldTxState,
@ -357,7 +357,7 @@ async function handlePeerPullCreditWithdrawing(
async function handlePeerPullCreditCreatePurse( async function handlePeerPullCreditCreatePurse(
ws: InternalWalletState, ws: InternalWalletState,
pullIni: PeerPullPaymentInitiationRecord, pullIni: PeerPullCreditRecord,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const purseFee = Amounts.stringify(Amounts.zeroOfAmount(pullIni.amount)); const purseFee = Amounts.stringify(Amounts.zeroOfAmount(pullIni.amount));
const pursePub = pullIni.pursePub; const pursePub = pullIni.pursePub;
@ -444,15 +444,15 @@ async function handlePeerPullCreditCreatePurse(
}); });
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations]) .mktx((x) => [x.peerPullCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pi2 = await tx.peerPullPaymentInitiations.get(pursePub); const pi2 = await tx.peerPullCredit.get(pursePub);
if (!pi2) { if (!pi2) {
return; return;
} }
const oldTxState = computePeerPullCreditTransactionState(pi2); const oldTxState = computePeerPullCreditTransactionState(pi2);
pi2.status = PeerPullPaymentInitiationStatus.PendingReady; pi2.status = PeerPullPaymentCreditStatus.PendingReady;
await tx.peerPullPaymentInitiations.put(pi2); await tx.peerPullCredit.put(pi2);
const newTxState = computePeerPullCreditTransactionState(pi2); const newTxState = computePeerPullCreditTransactionState(pi2);
return { oldTxState, newTxState }; return { oldTxState, newTxState };
}); });
@ -466,9 +466,9 @@ export async function processPeerPullCredit(
pursePub: string, pursePub: string,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const pullIni = await ws.db const pullIni = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations]) .mktx((x) => [x.peerPullCredit])
.runReadOnly(async (tx) => { .runReadOnly(async (tx) => {
return tx.peerPullPaymentInitiations.get(pursePub); return tx.peerPullCredit.get(pursePub);
}); });
if (!pullIni) { if (!pullIni) {
throw Error("peer pull payment initiation not found in database"); throw Error("peer pull payment initiation not found in database");
@ -490,10 +490,10 @@ export async function processPeerPullCredit(
logger.trace(`processing ${retryTag}, status=${pullIni.status}`); logger.trace(`processing ${retryTag}, status=${pullIni.status}`);
switch (pullIni.status) { switch (pullIni.status) {
case PeerPullPaymentInitiationStatus.Done: { case PeerPullPaymentCreditStatus.Done: {
return TaskRunResult.finished(); return TaskRunResult.finished();
} }
case PeerPullPaymentInitiationStatus.PendingReady: case PeerPullPaymentCreditStatus.PendingReady:
runLongpollAsync(ws, retryTag, async (cancellationToken) => runLongpollAsync(ws, retryTag, async (cancellationToken) =>
queryPurseForPeerPullCredit(ws, pullIni, cancellationToken), queryPurseForPeerPullCredit(ws, pullIni, cancellationToken),
); );
@ -503,7 +503,7 @@ export async function processPeerPullCredit(
return { return {
type: TaskRunResultType.Longpoll, type: TaskRunResultType.Longpoll,
}; };
case PeerPullPaymentInitiationStatus.PendingMergeKycRequired: { case PeerPullPaymentCreditStatus.PendingMergeKycRequired: {
if (!pullIni.kycInfo) { if (!pullIni.kycInfo) {
throw Error("invalid state, kycInfo required"); throw Error("invalid state, kycInfo required");
} }
@ -515,19 +515,19 @@ export async function processPeerPullCredit(
"individual", "individual",
); );
} }
case PeerPullPaymentInitiationStatus.PendingCreatePurse: case PeerPullPaymentCreditStatus.PendingCreatePurse:
return handlePeerPullCreditCreatePurse(ws, pullIni); return handlePeerPullCreditCreatePurse(ws, pullIni);
case PeerPullPaymentInitiationStatus.AbortingDeletePurse: case PeerPullPaymentCreditStatus.AbortingDeletePurse:
return await processPeerPullCreditAbortingDeletePurse(ws, pullIni); return await processPeerPullCreditAbortingDeletePurse(ws, pullIni);
case PeerPullPaymentInitiationStatus.PendingWithdrawing: case PeerPullPaymentCreditStatus.PendingWithdrawing:
return handlePeerPullCreditWithdrawing(ws, pullIni); return handlePeerPullCreditWithdrawing(ws, pullIni);
case PeerPullPaymentInitiationStatus.Aborted: case PeerPullPaymentCreditStatus.Aborted:
case PeerPullPaymentInitiationStatus.Failed: case PeerPullPaymentCreditStatus.Failed:
case PeerPullPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPullPaymentCreditStatus.SuspendedAbortingDeletePurse:
case PeerPullPaymentInitiationStatus.SuspendedCreatePurse: case PeerPullPaymentCreditStatus.SuspendedCreatePurse:
case PeerPullPaymentInitiationStatus.SuspendedMergeKycRequired: case PeerPullPaymentCreditStatus.SuspendedMergeKycRequired:
case PeerPullPaymentInitiationStatus.SuspendedReady: case PeerPullPaymentCreditStatus.SuspendedReady:
case PeerPullPaymentInitiationStatus.SuspendedWithdrawing: case PeerPullPaymentCreditStatus.SuspendedWithdrawing:
break; break;
default: default:
assertUnreachable(pullIni.status); assertUnreachable(pullIni.status);
@ -538,7 +538,7 @@ export async function processPeerPullCredit(
async function processPeerPullCreditKycRequired( async function processPeerPullCreditKycRequired(
ws: InternalWalletState, ws: InternalWalletState,
peerIni: PeerPullPaymentInitiationRecord, peerIni: PeerPullCreditRecord,
kycPending: WalletKycUuid, kycPending: WalletKycUuid,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
@ -570,9 +570,9 @@ async function processPeerPullCreditKycRequired(
const kycStatus = await kycStatusRes.json(); const kycStatus = await kycStatusRes.json();
logger.info(`kyc status: ${j2s(kycStatus)}`); logger.info(`kyc status: ${j2s(kycStatus)}`);
const { transitionInfo, result } = await ws.db const { transitionInfo, result } = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations]) .mktx((x) => [x.peerPullCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const peerInc = await tx.peerPullPaymentInitiations.get(pursePub); const peerInc = await tx.peerPullCredit.get(pursePub);
if (!peerInc) { if (!peerInc) {
return { return {
transitionInfo: undefined, transitionInfo: undefined,
@ -586,9 +586,9 @@ async function processPeerPullCreditKycRequired(
}; };
peerInc.kycUrl = kycStatus.kyc_url; peerInc.kycUrl = kycStatus.kyc_url;
peerInc.status = peerInc.status =
PeerPullPaymentInitiationStatus.PendingMergeKycRequired; PeerPullPaymentCreditStatus.PendingMergeKycRequired;
const newTxState = computePeerPullCreditTransactionState(peerInc); const newTxState = computePeerPullCreditTransactionState(peerInc);
await tx.peerPullPaymentInitiations.put(peerInc); await tx.peerPullCredit.put(peerInc);
// We'll remove this eventually! New clients should rely on the // We'll remove this eventually! New clients should rely on the
// kycUrl field of the transaction, not the error code. // kycUrl field of the transaction, not the error code.
const res: TaskRunResult = { const res: TaskRunResult = {
@ -758,9 +758,9 @@ export async function initiatePeerPullPayment(
); );
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations, x.contractTerms]) .mktx((x) => [x.peerPullCredit, x.contractTerms])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const ppi: PeerPullPaymentInitiationRecord = { const ppi: PeerPullCreditRecord = {
amount: req.partialContractTerms.amount, amount: req.partialContractTerms.amount,
contractTermsHash: hContractTerms, contractTermsHash: hContractTerms,
exchangeBaseUrl: exchangeBaseUrl, exchangeBaseUrl: exchangeBaseUrl,
@ -768,7 +768,7 @@ export async function initiatePeerPullPayment(
pursePub: pursePair.pub, pursePub: pursePair.pub,
mergePriv: mergePair.priv, mergePriv: mergePair.priv,
mergePub: mergePair.pub, mergePub: mergePair.pub,
status: PeerPullPaymentInitiationStatus.PendingCreatePurse, status: PeerPullPaymentCreditStatus.PendingCreatePurse,
contractTerms: contractTerms, contractTerms: contractTerms,
mergeTimestamp, mergeTimestamp,
contractEncNonce, contractEncNonce,
@ -778,7 +778,7 @@ export async function initiatePeerPullPayment(
withdrawalGroupId, withdrawalGroupId,
estimatedAmountEffective: wi.withdrawalAmountEffective, estimatedAmountEffective: wi.withdrawalAmountEffective,
}; };
await tx.peerPullPaymentInitiations.put(ppi); await tx.peerPullCredit.put(ppi);
const oldTxState: TransactionState = { const oldTxState: TransactionState = {
major: TransactionMajorState.None, major: TransactionMajorState.None,
}; };
@ -826,39 +826,39 @@ export async function suspendPeerPullCreditTransaction(
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations]) .mktx((x) => [x.peerPullCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pullCreditRec = await tx.peerPullPaymentInitiations.get(pursePub); const pullCreditRec = await tx.peerPullCredit.get(pursePub);
if (!pullCreditRec) { if (!pullCreditRec) {
logger.warn(`peer pull credit ${pursePub} not found`); logger.warn(`peer pull credit ${pursePub} not found`);
return; return;
} }
let newStatus: PeerPullPaymentInitiationStatus | undefined = undefined; let newStatus: PeerPullPaymentCreditStatus | undefined = undefined;
switch (pullCreditRec.status) { switch (pullCreditRec.status) {
case PeerPullPaymentInitiationStatus.PendingCreatePurse: case PeerPullPaymentCreditStatus.PendingCreatePurse:
newStatus = PeerPullPaymentInitiationStatus.SuspendedCreatePurse; newStatus = PeerPullPaymentCreditStatus.SuspendedCreatePurse;
break; break;
case PeerPullPaymentInitiationStatus.PendingMergeKycRequired: case PeerPullPaymentCreditStatus.PendingMergeKycRequired:
newStatus = PeerPullPaymentInitiationStatus.SuspendedMergeKycRequired; newStatus = PeerPullPaymentCreditStatus.SuspendedMergeKycRequired;
break; break;
case PeerPullPaymentInitiationStatus.PendingWithdrawing: case PeerPullPaymentCreditStatus.PendingWithdrawing:
newStatus = PeerPullPaymentInitiationStatus.SuspendedWithdrawing; newStatus = PeerPullPaymentCreditStatus.SuspendedWithdrawing;
break; break;
case PeerPullPaymentInitiationStatus.PendingReady: case PeerPullPaymentCreditStatus.PendingReady:
newStatus = PeerPullPaymentInitiationStatus.SuspendedReady; newStatus = PeerPullPaymentCreditStatus.SuspendedReady;
break; break;
case PeerPullPaymentInitiationStatus.AbortingDeletePurse: case PeerPullPaymentCreditStatus.AbortingDeletePurse:
newStatus = newStatus =
PeerPullPaymentInitiationStatus.SuspendedAbortingDeletePurse; PeerPullPaymentCreditStatus.SuspendedAbortingDeletePurse;
break; break;
case PeerPullPaymentInitiationStatus.Done: case PeerPullPaymentCreditStatus.Done:
case PeerPullPaymentInitiationStatus.SuspendedCreatePurse: case PeerPullPaymentCreditStatus.SuspendedCreatePurse:
case PeerPullPaymentInitiationStatus.SuspendedMergeKycRequired: case PeerPullPaymentCreditStatus.SuspendedMergeKycRequired:
case PeerPullPaymentInitiationStatus.SuspendedReady: case PeerPullPaymentCreditStatus.SuspendedReady:
case PeerPullPaymentInitiationStatus.SuspendedWithdrawing: case PeerPullPaymentCreditStatus.SuspendedWithdrawing:
case PeerPullPaymentInitiationStatus.Aborted: case PeerPullPaymentCreditStatus.Aborted:
case PeerPullPaymentInitiationStatus.Failed: case PeerPullPaymentCreditStatus.Failed:
case PeerPullPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPullPaymentCreditStatus.SuspendedAbortingDeletePurse:
break; break;
default: default:
assertUnreachable(pullCreditRec.status); assertUnreachable(pullCreditRec.status);
@ -867,7 +867,7 @@ export async function suspendPeerPullCreditTransaction(
const oldTxState = computePeerPullCreditTransactionState(pullCreditRec); const oldTxState = computePeerPullCreditTransactionState(pullCreditRec);
pullCreditRec.status = newStatus; pullCreditRec.status = newStatus;
const newTxState = computePeerPullCreditTransactionState(pullCreditRec); const newTxState = computePeerPullCreditTransactionState(pullCreditRec);
await tx.peerPullPaymentInitiations.put(pullCreditRec); await tx.peerPullCredit.put(pullCreditRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -892,33 +892,33 @@ export async function abortPeerPullCreditTransaction(
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations]) .mktx((x) => [x.peerPullCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pullCreditRec = await tx.peerPullPaymentInitiations.get(pursePub); const pullCreditRec = await tx.peerPullCredit.get(pursePub);
if (!pullCreditRec) { if (!pullCreditRec) {
logger.warn(`peer pull credit ${pursePub} not found`); logger.warn(`peer pull credit ${pursePub} not found`);
return; return;
} }
let newStatus: PeerPullPaymentInitiationStatus | undefined = undefined; let newStatus: PeerPullPaymentCreditStatus | undefined = undefined;
switch (pullCreditRec.status) { switch (pullCreditRec.status) {
case PeerPullPaymentInitiationStatus.PendingCreatePurse: case PeerPullPaymentCreditStatus.PendingCreatePurse:
case PeerPullPaymentInitiationStatus.PendingMergeKycRequired: case PeerPullPaymentCreditStatus.PendingMergeKycRequired:
newStatus = PeerPullPaymentInitiationStatus.AbortingDeletePurse; newStatus = PeerPullPaymentCreditStatus.AbortingDeletePurse;
break; break;
case PeerPullPaymentInitiationStatus.PendingWithdrawing: case PeerPullPaymentCreditStatus.PendingWithdrawing:
throw Error("can't abort anymore"); throw Error("can't abort anymore");
case PeerPullPaymentInitiationStatus.PendingReady: case PeerPullPaymentCreditStatus.PendingReady:
newStatus = PeerPullPaymentInitiationStatus.AbortingDeletePurse; newStatus = PeerPullPaymentCreditStatus.AbortingDeletePurse;
break; break;
case PeerPullPaymentInitiationStatus.Done: case PeerPullPaymentCreditStatus.Done:
case PeerPullPaymentInitiationStatus.SuspendedCreatePurse: case PeerPullPaymentCreditStatus.SuspendedCreatePurse:
case PeerPullPaymentInitiationStatus.SuspendedMergeKycRequired: case PeerPullPaymentCreditStatus.SuspendedMergeKycRequired:
case PeerPullPaymentInitiationStatus.SuspendedReady: case PeerPullPaymentCreditStatus.SuspendedReady:
case PeerPullPaymentInitiationStatus.SuspendedWithdrawing: case PeerPullPaymentCreditStatus.SuspendedWithdrawing:
case PeerPullPaymentInitiationStatus.Aborted: case PeerPullPaymentCreditStatus.Aborted:
case PeerPullPaymentInitiationStatus.AbortingDeletePurse: case PeerPullPaymentCreditStatus.AbortingDeletePurse:
case PeerPullPaymentInitiationStatus.Failed: case PeerPullPaymentCreditStatus.Failed:
case PeerPullPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPullPaymentCreditStatus.SuspendedAbortingDeletePurse:
break; break;
default: default:
assertUnreachable(pullCreditRec.status); assertUnreachable(pullCreditRec.status);
@ -927,7 +927,7 @@ export async function abortPeerPullCreditTransaction(
const oldTxState = computePeerPullCreditTransactionState(pullCreditRec); const oldTxState = computePeerPullCreditTransactionState(pullCreditRec);
pullCreditRec.status = newStatus; pullCreditRec.status = newStatus;
const newTxState = computePeerPullCreditTransactionState(pullCreditRec); const newTxState = computePeerPullCreditTransactionState(pullCreditRec);
await tx.peerPullPaymentInitiations.put(pullCreditRec); await tx.peerPullCredit.put(pullCreditRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -952,30 +952,30 @@ export async function failPeerPullCreditTransaction(
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations]) .mktx((x) => [x.peerPullCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pullCreditRec = await tx.peerPullPaymentInitiations.get(pursePub); const pullCreditRec = await tx.peerPullCredit.get(pursePub);
if (!pullCreditRec) { if (!pullCreditRec) {
logger.warn(`peer pull credit ${pursePub} not found`); logger.warn(`peer pull credit ${pursePub} not found`);
return; return;
} }
let newStatus: PeerPullPaymentInitiationStatus | undefined = undefined; let newStatus: PeerPullPaymentCreditStatus | undefined = undefined;
switch (pullCreditRec.status) { switch (pullCreditRec.status) {
case PeerPullPaymentInitiationStatus.PendingCreatePurse: case PeerPullPaymentCreditStatus.PendingCreatePurse:
case PeerPullPaymentInitiationStatus.PendingMergeKycRequired: case PeerPullPaymentCreditStatus.PendingMergeKycRequired:
case PeerPullPaymentInitiationStatus.PendingWithdrawing: case PeerPullPaymentCreditStatus.PendingWithdrawing:
case PeerPullPaymentInitiationStatus.PendingReady: case PeerPullPaymentCreditStatus.PendingReady:
case PeerPullPaymentInitiationStatus.Done: case PeerPullPaymentCreditStatus.Done:
case PeerPullPaymentInitiationStatus.SuspendedCreatePurse: case PeerPullPaymentCreditStatus.SuspendedCreatePurse:
case PeerPullPaymentInitiationStatus.SuspendedMergeKycRequired: case PeerPullPaymentCreditStatus.SuspendedMergeKycRequired:
case PeerPullPaymentInitiationStatus.SuspendedReady: case PeerPullPaymentCreditStatus.SuspendedReady:
case PeerPullPaymentInitiationStatus.SuspendedWithdrawing: case PeerPullPaymentCreditStatus.SuspendedWithdrawing:
case PeerPullPaymentInitiationStatus.Aborted: case PeerPullPaymentCreditStatus.Aborted:
case PeerPullPaymentInitiationStatus.Failed: case PeerPullPaymentCreditStatus.Failed:
break; break;
case PeerPullPaymentInitiationStatus.AbortingDeletePurse: case PeerPullPaymentCreditStatus.AbortingDeletePurse:
case PeerPullPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPullPaymentCreditStatus.SuspendedAbortingDeletePurse:
newStatus = PeerPullPaymentInitiationStatus.Failed; newStatus = PeerPullPaymentCreditStatus.Failed;
break; break;
default: default:
assertUnreachable(pullCreditRec.status); assertUnreachable(pullCreditRec.status);
@ -984,7 +984,7 @@ export async function failPeerPullCreditTransaction(
const oldTxState = computePeerPullCreditTransactionState(pullCreditRec); const oldTxState = computePeerPullCreditTransactionState(pullCreditRec);
pullCreditRec.status = newStatus; pullCreditRec.status = newStatus;
const newTxState = computePeerPullCreditTransactionState(pullCreditRec); const newTxState = computePeerPullCreditTransactionState(pullCreditRec);
await tx.peerPullPaymentInitiations.put(pullCreditRec); await tx.peerPullCredit.put(pullCreditRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -1009,38 +1009,38 @@ export async function resumePeerPullCreditTransaction(
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentInitiations]) .mktx((x) => [x.peerPullCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pullCreditRec = await tx.peerPullPaymentInitiations.get(pursePub); const pullCreditRec = await tx.peerPullCredit.get(pursePub);
if (!pullCreditRec) { if (!pullCreditRec) {
logger.warn(`peer pull credit ${pursePub} not found`); logger.warn(`peer pull credit ${pursePub} not found`);
return; return;
} }
let newStatus: PeerPullPaymentInitiationStatus | undefined = undefined; let newStatus: PeerPullPaymentCreditStatus | undefined = undefined;
switch (pullCreditRec.status) { switch (pullCreditRec.status) {
case PeerPullPaymentInitiationStatus.PendingCreatePurse: case PeerPullPaymentCreditStatus.PendingCreatePurse:
case PeerPullPaymentInitiationStatus.PendingMergeKycRequired: case PeerPullPaymentCreditStatus.PendingMergeKycRequired:
case PeerPullPaymentInitiationStatus.PendingWithdrawing: case PeerPullPaymentCreditStatus.PendingWithdrawing:
case PeerPullPaymentInitiationStatus.PendingReady: case PeerPullPaymentCreditStatus.PendingReady:
case PeerPullPaymentInitiationStatus.AbortingDeletePurse: case PeerPullPaymentCreditStatus.AbortingDeletePurse:
case PeerPullPaymentInitiationStatus.Done: case PeerPullPaymentCreditStatus.Done:
case PeerPullPaymentInitiationStatus.Failed: case PeerPullPaymentCreditStatus.Failed:
case PeerPullPaymentInitiationStatus.Aborted: case PeerPullPaymentCreditStatus.Aborted:
break; break;
case PeerPullPaymentInitiationStatus.SuspendedCreatePurse: case PeerPullPaymentCreditStatus.SuspendedCreatePurse:
newStatus = PeerPullPaymentInitiationStatus.PendingCreatePurse; newStatus = PeerPullPaymentCreditStatus.PendingCreatePurse;
break; break;
case PeerPullPaymentInitiationStatus.SuspendedMergeKycRequired: case PeerPullPaymentCreditStatus.SuspendedMergeKycRequired:
newStatus = PeerPullPaymentInitiationStatus.PendingMergeKycRequired; newStatus = PeerPullPaymentCreditStatus.PendingMergeKycRequired;
break; break;
case PeerPullPaymentInitiationStatus.SuspendedReady: case PeerPullPaymentCreditStatus.SuspendedReady:
newStatus = PeerPullPaymentInitiationStatus.PendingReady; newStatus = PeerPullPaymentCreditStatus.PendingReady;
break; break;
case PeerPullPaymentInitiationStatus.SuspendedWithdrawing: case PeerPullPaymentCreditStatus.SuspendedWithdrawing:
newStatus = PeerPullPaymentInitiationStatus.PendingWithdrawing; newStatus = PeerPullPaymentCreditStatus.PendingWithdrawing;
break; break;
case PeerPullPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPullPaymentCreditStatus.SuspendedAbortingDeletePurse:
newStatus = PeerPullPaymentInitiationStatus.AbortingDeletePurse; newStatus = PeerPullPaymentCreditStatus.AbortingDeletePurse;
break; break;
default: default:
assertUnreachable(pullCreditRec.status); assertUnreachable(pullCreditRec.status);
@ -1049,7 +1049,7 @@ export async function resumePeerPullCreditTransaction(
const oldTxState = computePeerPullCreditTransactionState(pullCreditRec); const oldTxState = computePeerPullCreditTransactionState(pullCreditRec);
pullCreditRec.status = newStatus; pullCreditRec.status = newStatus;
const newTxState = computePeerPullCreditTransactionState(pullCreditRec); const newTxState = computePeerPullCreditTransactionState(pullCreditRec);
await tx.peerPullPaymentInitiations.put(pullCreditRec); await tx.peerPullCredit.put(pullCreditRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -1062,67 +1062,67 @@ export async function resumePeerPullCreditTransaction(
} }
export function computePeerPullCreditTransactionState( export function computePeerPullCreditTransactionState(
pullCreditRecord: PeerPullPaymentInitiationRecord, pullCreditRecord: PeerPullCreditRecord,
): TransactionState { ): TransactionState {
switch (pullCreditRecord.status) { switch (pullCreditRecord.status) {
case PeerPullPaymentInitiationStatus.PendingCreatePurse: case PeerPullPaymentCreditStatus.PendingCreatePurse:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.CreatePurse, minor: TransactionMinorState.CreatePurse,
}; };
case PeerPullPaymentInitiationStatus.PendingMergeKycRequired: case PeerPullPaymentCreditStatus.PendingMergeKycRequired:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.MergeKycRequired, minor: TransactionMinorState.MergeKycRequired,
}; };
case PeerPullPaymentInitiationStatus.PendingReady: case PeerPullPaymentCreditStatus.PendingReady:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.Ready, minor: TransactionMinorState.Ready,
}; };
case PeerPullPaymentInitiationStatus.Done: case PeerPullPaymentCreditStatus.Done:
return { return {
major: TransactionMajorState.Done, major: TransactionMajorState.Done,
}; };
case PeerPullPaymentInitiationStatus.PendingWithdrawing: case PeerPullPaymentCreditStatus.PendingWithdrawing:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.Withdraw, minor: TransactionMinorState.Withdraw,
}; };
case PeerPullPaymentInitiationStatus.SuspendedCreatePurse: case PeerPullPaymentCreditStatus.SuspendedCreatePurse:
return { return {
major: TransactionMajorState.Suspended, major: TransactionMajorState.Suspended,
minor: TransactionMinorState.CreatePurse, minor: TransactionMinorState.CreatePurse,
}; };
case PeerPullPaymentInitiationStatus.SuspendedReady: case PeerPullPaymentCreditStatus.SuspendedReady:
return { return {
major: TransactionMajorState.Suspended, major: TransactionMajorState.Suspended,
minor: TransactionMinorState.Ready, minor: TransactionMinorState.Ready,
}; };
case PeerPullPaymentInitiationStatus.SuspendedWithdrawing: case PeerPullPaymentCreditStatus.SuspendedWithdrawing:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.Withdraw, minor: TransactionMinorState.Withdraw,
}; };
case PeerPullPaymentInitiationStatus.SuspendedMergeKycRequired: case PeerPullPaymentCreditStatus.SuspendedMergeKycRequired:
return { return {
major: TransactionMajorState.Suspended, major: TransactionMajorState.Suspended,
minor: TransactionMinorState.MergeKycRequired, minor: TransactionMinorState.MergeKycRequired,
}; };
case PeerPullPaymentInitiationStatus.Aborted: case PeerPullPaymentCreditStatus.Aborted:
return { return {
major: TransactionMajorState.Aborted, major: TransactionMajorState.Aborted,
}; };
case PeerPullPaymentInitiationStatus.AbortingDeletePurse: case PeerPullPaymentCreditStatus.AbortingDeletePurse:
return { return {
major: TransactionMajorState.Aborting, major: TransactionMajorState.Aborting,
minor: TransactionMinorState.DeletePurse, minor: TransactionMinorState.DeletePurse,
}; };
case PeerPullPaymentInitiationStatus.Failed: case PeerPullPaymentCreditStatus.Failed:
return { return {
major: TransactionMajorState.Failed, major: TransactionMajorState.Failed,
}; };
case PeerPullPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPullPaymentCreditStatus.SuspendedAbortingDeletePurse:
return { return {
major: TransactionMajorState.Aborting, major: TransactionMajorState.Aborting,
minor: TransactionMinorState.DeletePurse, minor: TransactionMinorState.DeletePurse,
@ -1131,34 +1131,34 @@ export function computePeerPullCreditTransactionState(
} }
export function computePeerPullCreditTransactionActions( export function computePeerPullCreditTransactionActions(
pullCreditRecord: PeerPullPaymentInitiationRecord, pullCreditRecord: PeerPullCreditRecord,
): TransactionAction[] { ): TransactionAction[] {
switch (pullCreditRecord.status) { switch (pullCreditRecord.status) {
case PeerPullPaymentInitiationStatus.PendingCreatePurse: case PeerPullPaymentCreditStatus.PendingCreatePurse:
return [TransactionAction.Abort, TransactionAction.Suspend]; return [TransactionAction.Abort, TransactionAction.Suspend];
case PeerPullPaymentInitiationStatus.PendingMergeKycRequired: case PeerPullPaymentCreditStatus.PendingMergeKycRequired:
return [TransactionAction.Abort, TransactionAction.Suspend]; return [TransactionAction.Abort, TransactionAction.Suspend];
case PeerPullPaymentInitiationStatus.PendingReady: case PeerPullPaymentCreditStatus.PendingReady:
return [TransactionAction.Abort, TransactionAction.Suspend]; return [TransactionAction.Abort, TransactionAction.Suspend];
case PeerPullPaymentInitiationStatus.Done: case PeerPullPaymentCreditStatus.Done:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PeerPullPaymentInitiationStatus.PendingWithdrawing: case PeerPullPaymentCreditStatus.PendingWithdrawing:
return [TransactionAction.Abort, TransactionAction.Suspend]; return [TransactionAction.Abort, TransactionAction.Suspend];
case PeerPullPaymentInitiationStatus.SuspendedCreatePurse: case PeerPullPaymentCreditStatus.SuspendedCreatePurse:
return [TransactionAction.Resume, TransactionAction.Abort]; return [TransactionAction.Resume, TransactionAction.Abort];
case PeerPullPaymentInitiationStatus.SuspendedReady: case PeerPullPaymentCreditStatus.SuspendedReady:
return [TransactionAction.Abort, TransactionAction.Resume]; return [TransactionAction.Abort, TransactionAction.Resume];
case PeerPullPaymentInitiationStatus.SuspendedWithdrawing: case PeerPullPaymentCreditStatus.SuspendedWithdrawing:
return [TransactionAction.Resume, TransactionAction.Fail]; return [TransactionAction.Resume, TransactionAction.Fail];
case PeerPullPaymentInitiationStatus.SuspendedMergeKycRequired: case PeerPullPaymentCreditStatus.SuspendedMergeKycRequired:
return [TransactionAction.Resume, TransactionAction.Fail]; return [TransactionAction.Resume, TransactionAction.Fail];
case PeerPullPaymentInitiationStatus.Aborted: case PeerPullPaymentCreditStatus.Aborted:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PeerPullPaymentInitiationStatus.AbortingDeletePurse: case PeerPullPaymentCreditStatus.AbortingDeletePurse:
return [TransactionAction.Suspend, TransactionAction.Fail]; return [TransactionAction.Suspend, TransactionAction.Fail];
case PeerPullPaymentInitiationStatus.Failed: case PeerPullPaymentCreditStatus.Failed:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PeerPullPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPullPaymentCreditStatus.SuspendedAbortingDeletePurse:
return [TransactionAction.Resume, TransactionAction.Fail]; return [TransactionAction.Resume, TransactionAction.Fail];
} }
} }

178
packages/taler-wallet-core/src/operations/pay-peer-pull-debit.ts
View File

@ -140,10 +140,10 @@ async function handlePurseCreationConflict(
); );
await ws.db await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const myPpi = await tx.peerPullPaymentIncoming.get( const myPpi = await tx.peerPullDebit.get(
peerPullInc.peerPullPaymentIncomingId, peerPullInc.peerPullDebitId,
); );
if (!myPpi) { if (!myPpi) {
return; return;
@ -162,7 +162,7 @@ async function handlePurseCreationConflict(
default: default:
return; return;
} }
await tx.peerPullPaymentIncoming.put(myPpi); await tx.peerPullDebit.put(myPpi);
}); });
return TaskRunResult.finished(); return TaskRunResult.finished();
} }
@ -171,7 +171,7 @@ async function processPeerPullDebitPendingDeposit(
ws: InternalWalletState, ws: InternalWalletState,
peerPullInc: PeerPullPaymentIncomingRecord, peerPullInc: PeerPullPaymentIncomingRecord,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const peerPullPaymentIncomingId = peerPullInc.peerPullPaymentIncomingId; const peerPullDebitId = peerPullInc.peerPullDebitId;
const pursePub = peerPullInc.pursePub; const pursePub = peerPullInc.pursePub;
const coinSel = peerPullInc.coinSel; const coinSel = peerPullInc.coinSel;
@ -202,7 +202,7 @@ async function processPeerPullDebitPendingDeposit(
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
const httpResp = await ws.http.fetch(purseDepositUrl.href, { const httpResp = await ws.http.fetch(purseDepositUrl.href, {
@ -218,10 +218,10 @@ async function processPeerPullDebitPendingDeposit(
logger.trace(`purse deposit response: ${j2s(resp)}`); logger.trace(`purse deposit response: ${j2s(resp)}`);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pi = await tx.peerPullPaymentIncoming.get( const pi = await tx.peerPullDebit.get(
peerPullPaymentIncomingId, peerPullDebitId,
); );
if (!pi) { if (!pi) {
throw Error("peer pull payment not found anymore"); throw Error("peer pull payment not found anymore");
@ -230,9 +230,9 @@ async function processPeerPullDebitPendingDeposit(
return; return;
} }
const oldTxState = computePeerPullDebitTransactionState(pi); const oldTxState = computePeerPullDebitTransactionState(pi);
pi.status = PeerPullDebitRecordStatus.DonePaid; pi.status = PeerPullDebitRecordStatus.Done;
const newTxState = computePeerPullDebitTransactionState(pi); const newTxState = computePeerPullDebitTransactionState(pi);
await tx.peerPullPaymentIncoming.put(pi); await tx.peerPullDebit.put(pi);
return { oldTxState, newTxState }; return { oldTxState, newTxState };
}); });
notifyTransition(ws, transactionId, transitionInfo); notifyTransition(ws, transactionId, transitionInfo);
@ -241,15 +241,15 @@ async function processPeerPullDebitPendingDeposit(
case HttpStatusCode.Gone: { case HttpStatusCode.Gone: {
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [ .mktx((x) => [
x.peerPullPaymentIncoming, x.peerPullDebit,
x.refreshGroups, x.refreshGroups,
x.denominations, x.denominations,
x.coinAvailability, x.coinAvailability,
x.coins, x.coins,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pi = await tx.peerPullPaymentIncoming.get( const pi = await tx.peerPullDebit.get(
peerPullPaymentIncomingId, peerPullDebitId,
); );
if (!pi) { if (!pi) {
throw Error("peer pull payment not found anymore"); throw Error("peer pull payment not found anymore");
@ -284,7 +284,7 @@ async function processPeerPullDebitPendingDeposit(
pi.status = PeerPullDebitRecordStatus.AbortingRefresh; pi.status = PeerPullDebitRecordStatus.AbortingRefresh;
pi.abortRefreshGroupId = refresh.refreshGroupId; pi.abortRefreshGroupId = refresh.refreshGroupId;
const newTxState = computePeerPullDebitTransactionState(pi); const newTxState = computePeerPullDebitTransactionState(pi);
await tx.peerPullPaymentIncoming.put(pi); await tx.peerPullDebit.put(pi);
return { oldTxState, newTxState }; return { oldTxState, newTxState };
}); });
notifyTransition(ws, transactionId, transitionInfo); notifyTransition(ws, transactionId, transitionInfo);
@ -308,15 +308,15 @@ async function processPeerPullDebitAbortingRefresh(
ws: InternalWalletState, ws: InternalWalletState,
peerPullInc: PeerPullPaymentIncomingRecord, peerPullInc: PeerPullPaymentIncomingRecord,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const peerPullPaymentIncomingId = peerPullInc.peerPullPaymentIncomingId; const peerPullDebitId = peerPullInc.peerPullDebitId;
const abortRefreshGroupId = peerPullInc.abortRefreshGroupId; const abortRefreshGroupId = peerPullInc.abortRefreshGroupId;
checkLogicInvariant(!!abortRefreshGroupId); checkLogicInvariant(!!abortRefreshGroupId);
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.refreshGroups, x.peerPullPaymentIncoming]) .mktx((x) => [x.refreshGroups, x.peerPullDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const refreshGroup = await tx.refreshGroups.get(abortRefreshGroupId); const refreshGroup = await tx.refreshGroups.get(abortRefreshGroupId);
let newOpState: PeerPullDebitRecordStatus | undefined; let newOpState: PeerPullDebitRecordStatus | undefined;
@ -335,8 +335,8 @@ async function processPeerPullDebitAbortingRefresh(
} }
} }
if (newOpState) { if (newOpState) {
const newDg = await tx.peerPullPaymentIncoming.get( const newDg = await tx.peerPullDebit.get(
peerPullPaymentIncomingId, peerPullDebitId,
); );
if (!newDg) { if (!newDg) {
return; return;
@ -344,7 +344,7 @@ async function processPeerPullDebitAbortingRefresh(
const oldTxState = computePeerPullDebitTransactionState(newDg); const oldTxState = computePeerPullDebitTransactionState(newDg);
newDg.status = newOpState; newDg.status = newOpState;
const newTxState = computePeerPullDebitTransactionState(newDg); const newTxState = computePeerPullDebitTransactionState(newDg);
await tx.peerPullPaymentIncoming.put(newDg); await tx.peerPullDebit.put(newDg);
return { oldTxState, newTxState }; return { oldTxState, newTxState };
} }
return undefined; return undefined;
@ -356,12 +356,12 @@ async function processPeerPullDebitAbortingRefresh(
export async function processPeerPullDebit( export async function processPeerPullDebit(
ws: InternalWalletState, ws: InternalWalletState,
peerPullPaymentIncomingId: string, peerPullDebitId: string,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const peerPullInc = await ws.db const peerPullInc = await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadOnly(async (tx) => { .runReadOnly(async (tx) => {
return tx.peerPullPaymentIncoming.get(peerPullPaymentIncomingId); return tx.peerPullDebit.get(peerPullDebitId);
}); });
if (!peerPullInc) { if (!peerPullInc) {
throw Error("peer pull debit not found"); throw Error("peer pull debit not found");
@ -380,31 +380,31 @@ export async function confirmPeerPullDebit(
ws: InternalWalletState, ws: InternalWalletState,
req: ConfirmPeerPullDebitRequest, req: ConfirmPeerPullDebitRequest,
): Promise<AcceptPeerPullPaymentResponse> { ): Promise<AcceptPeerPullPaymentResponse> {
let peerPullPaymentIncomingId: string; let peerPullDebitId: string;
if (req.transactionId) { if (req.transactionId) {
const parsedTx = parseTransactionIdentifier(req.transactionId); const parsedTx = parseTransactionIdentifier(req.transactionId);
if (!parsedTx || parsedTx.tag !== TransactionType.PeerPullDebit) { if (!parsedTx || parsedTx.tag !== TransactionType.PeerPullDebit) {
throw Error("invalid peer-pull-debit transaction identifier"); throw Error("invalid peer-pull-debit transaction identifier");
} }
peerPullPaymentIncomingId = parsedTx.peerPullPaymentIncomingId; peerPullDebitId = parsedTx.peerPullDebitId;
} else if (req.peerPullPaymentIncomingId) { } else if (req.peerPullDebitId) {
peerPullPaymentIncomingId = req.peerPullPaymentIncomingId; peerPullDebitId = req.peerPullDebitId;
} else { } else {
throw Error( throw Error(
"invalid request, transactionId or peerPullPaymentIncomingId required", "invalid request, transactionId or peerPullDebitId required",
); );
} }
const peerPullInc = await ws.db const peerPullInc = await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadOnly(async (tx) => { .runReadOnly(async (tx) => {
return tx.peerPullPaymentIncoming.get(peerPullPaymentIncomingId); return tx.peerPullDebit.get(peerPullDebitId);
}); });
if (!peerPullInc) { if (!peerPullInc) {
throw Error( throw Error(
`can't accept unknown incoming p2p pull payment (${req.peerPullPaymentIncomingId})`, `can't accept unknown incoming p2p pull payment (${req.peerPullDebitId})`,
); );
} }
@ -437,15 +437,15 @@ export async function confirmPeerPullDebit(
x.coins, x.coins,
x.denominations, x.denominations,
x.refreshGroups, x.refreshGroups,
x.peerPullPaymentIncoming, x.peerPullDebit,
x.coinAvailability, x.coinAvailability,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
await spendCoins(ws, tx, { await spendCoins(ws, tx, {
// allocationId: `txn:peer-pull-debit:${req.peerPullPaymentIncomingId}`, // allocationId: `txn:peer-pull-debit:${req.peerPullDebitId}`,
allocationId: constructTransactionIdentifier({ allocationId: constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}), }),
coinPubs: sel.coins.map((x) => x.coinPub), coinPubs: sel.coins.map((x) => x.coinPub),
contributions: sel.coins.map((x) => contributions: sel.coins.map((x) =>
@ -454,8 +454,8 @@ export async function confirmPeerPullDebit(
refreshReason: RefreshReason.PayPeerPull, refreshReason: RefreshReason.PayPeerPull,
}); });
const pi = await tx.peerPullPaymentIncoming.get( const pi = await tx.peerPullDebit.get(
peerPullPaymentIncomingId, peerPullDebitId,
); );
if (!pi) { if (!pi) {
throw Error(); throw Error();
@ -468,7 +468,7 @@ export async function confirmPeerPullDebit(
totalCost: Amounts.stringify(totalAmount), totalCost: Amounts.stringify(totalAmount),
}; };
} }
await tx.peerPullPaymentIncoming.put(pi); await tx.peerPullDebit.put(pi);
return pi; return pi;
}); });
@ -476,7 +476,7 @@ export async function confirmPeerPullDebit(
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
return { return {
@ -499,9 +499,9 @@ export async function preparePeerPullDebit(
} }
const existingPullIncomingRecord = await ws.db const existingPullIncomingRecord = await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadOnly(async (tx) => { .runReadOnly(async (tx) => {
return tx.peerPullPaymentIncoming.indexes.byExchangeAndContractPriv.get([ return tx.peerPullDebit.indexes.byExchangeAndContractPriv.get([
uri.exchangeBaseUrl, uri.exchangeBaseUrl,
uri.contractPriv, uri.contractPriv,
]); ]);
@ -513,12 +513,12 @@ export async function preparePeerPullDebit(
amountRaw: existingPullIncomingRecord.contractTerms.amount, amountRaw: existingPullIncomingRecord.contractTerms.amount,
amountEffective: existingPullIncomingRecord.totalCostEstimated, amountEffective: existingPullIncomingRecord.totalCostEstimated,
contractTerms: existingPullIncomingRecord.contractTerms, contractTerms: existingPullIncomingRecord.contractTerms,
peerPullPaymentIncomingId: peerPullDebitId:
existingPullIncomingRecord.peerPullPaymentIncomingId, existingPullIncomingRecord.peerPullDebitId,
transactionId: constructTransactionIdentifier({ transactionId: constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId: peerPullDebitId:
existingPullIncomingRecord.peerPullPaymentIncomingId, existingPullIncomingRecord.peerPullDebitId,
}), }),
}; };
} }
@ -553,7 +553,7 @@ export async function preparePeerPullDebit(
codecForExchangePurseStatus(), codecForExchangePurseStatus(),
); );
const peerPullPaymentIncomingId = encodeCrock(getRandomBytes(32)); const peerPullDebitId = encodeCrock(getRandomBytes(32));
let contractTerms: PeerContractTerms; let contractTerms: PeerContractTerms;
@ -588,10 +588,10 @@ export async function preparePeerPullDebit(
); );
await ws.db await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
await tx.peerPullPaymentIncoming.add({ await tx.peerPullDebit.add({
peerPullPaymentIncomingId, peerPullDebitId,
contractPriv: contractPriv, contractPriv: contractPriv,
exchangeBaseUrl: exchangeBaseUrl, exchangeBaseUrl: exchangeBaseUrl,
pursePub: pursePub, pursePub: pursePub,
@ -607,42 +607,42 @@ export async function preparePeerPullDebit(
amountEffective: Amounts.stringify(totalAmount), amountEffective: Amounts.stringify(totalAmount),
amountRaw: contractTerms.amount, amountRaw: contractTerms.amount,
contractTerms: contractTerms, contractTerms: contractTerms,
peerPullPaymentIncomingId, peerPullDebitId,
transactionId: constructTransactionIdentifier({ transactionId: constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId: peerPullPaymentIncomingId, peerPullDebitId: peerPullDebitId,
}), }),
}; };
} }
export async function suspendPeerPullDebitTransaction( export async function suspendPeerPullDebitTransaction(
ws: InternalWalletState, ws: InternalWalletState,
peerPullPaymentIncomingId: string, peerPullDebitId: string,
) { ) {
const taskId = constructTaskIdentifier({ const taskId = constructTaskIdentifier({
tag: PendingTaskType.PeerPullDebit, tag: PendingTaskType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pullDebitRec = await tx.peerPullPaymentIncoming.get( const pullDebitRec = await tx.peerPullDebit.get(
peerPullPaymentIncomingId, peerPullDebitId,
); );
if (!pullDebitRec) { if (!pullDebitRec) {
logger.warn(`peer pull debit ${peerPullPaymentIncomingId} not found`); logger.warn(`peer pull debit ${peerPullDebitId} not found`);
return; return;
} }
let newStatus: PeerPullDebitRecordStatus | undefined = undefined; let newStatus: PeerPullDebitRecordStatus | undefined = undefined;
switch (pullDebitRec.status) { switch (pullDebitRec.status) {
case PeerPullDebitRecordStatus.DialogProposed: case PeerPullDebitRecordStatus.DialogProposed:
break; break;
case PeerPullDebitRecordStatus.DonePaid: case PeerPullDebitRecordStatus.Done:
break; break;
case PeerPullDebitRecordStatus.PendingDeposit: case PeerPullDebitRecordStatus.PendingDeposit:
newStatus = PeerPullDebitRecordStatus.SuspendedDeposit; newStatus = PeerPullDebitRecordStatus.SuspendedDeposit;
@ -665,7 +665,7 @@ export async function suspendPeerPullDebitTransaction(
const oldTxState = computePeerPullDebitTransactionState(pullDebitRec); const oldTxState = computePeerPullDebitTransactionState(pullDebitRec);
pullDebitRec.status = newStatus; pullDebitRec.status = newStatus;
const newTxState = computePeerPullDebitTransactionState(pullDebitRec); const newTxState = computePeerPullDebitTransactionState(pullDebitRec);
await tx.peerPullPaymentIncoming.put(pullDebitRec); await tx.peerPullDebit.put(pullDebitRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -678,25 +678,25 @@ export async function suspendPeerPullDebitTransaction(
export async function abortPeerPullDebitTransaction( export async function abortPeerPullDebitTransaction(
ws: InternalWalletState, ws: InternalWalletState,
peerPullPaymentIncomingId: string, peerPullDebitId: string,
) { ) {
const taskId = constructTaskIdentifier({ const taskId = constructTaskIdentifier({
tag: PendingTaskType.PeerPullDebit, tag: PendingTaskType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pullDebitRec = await tx.peerPullPaymentIncoming.get( const pullDebitRec = await tx.peerPullDebit.get(
peerPullPaymentIncomingId, peerPullDebitId,
); );
if (!pullDebitRec) { if (!pullDebitRec) {
logger.warn(`peer pull debit ${peerPullPaymentIncomingId} not found`); logger.warn(`peer pull debit ${peerPullDebitId} not found`);
return; return;
} }
let newStatus: PeerPullDebitRecordStatus | undefined = undefined; let newStatus: PeerPullDebitRecordStatus | undefined = undefined;
@ -704,7 +704,7 @@ export async function abortPeerPullDebitTransaction(
case PeerPullDebitRecordStatus.DialogProposed: case PeerPullDebitRecordStatus.DialogProposed:
newStatus = PeerPullDebitRecordStatus.Aborted; newStatus = PeerPullDebitRecordStatus.Aborted;
break; break;
case PeerPullDebitRecordStatus.DonePaid: case PeerPullDebitRecordStatus.Done:
break; break;
case PeerPullDebitRecordStatus.PendingDeposit: case PeerPullDebitRecordStatus.PendingDeposit:
newStatus = PeerPullDebitRecordStatus.AbortingRefresh; newStatus = PeerPullDebitRecordStatus.AbortingRefresh;
@ -726,7 +726,7 @@ export async function abortPeerPullDebitTransaction(
const oldTxState = computePeerPullDebitTransactionState(pullDebitRec); const oldTxState = computePeerPullDebitTransactionState(pullDebitRec);
pullDebitRec.status = newStatus; pullDebitRec.status = newStatus;
const newTxState = computePeerPullDebitTransactionState(pullDebitRec); const newTxState = computePeerPullDebitTransactionState(pullDebitRec);
await tx.peerPullPaymentIncoming.put(pullDebitRec); await tx.peerPullDebit.put(pullDebitRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -739,25 +739,25 @@ export async function abortPeerPullDebitTransaction(
export async function failPeerPullDebitTransaction( export async function failPeerPullDebitTransaction(
ws: InternalWalletState, ws: InternalWalletState,
peerPullPaymentIncomingId: string, peerPullDebitId: string,
) { ) {
const taskId = constructTaskIdentifier({ const taskId = constructTaskIdentifier({
tag: PendingTaskType.PeerPullDebit, tag: PendingTaskType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pullDebitRec = await tx.peerPullPaymentIncoming.get( const pullDebitRec = await tx.peerPullDebit.get(
peerPullPaymentIncomingId, peerPullDebitId,
); );
if (!pullDebitRec) { if (!pullDebitRec) {
logger.warn(`peer pull debit ${peerPullPaymentIncomingId} not found`); logger.warn(`peer pull debit ${peerPullDebitId} not found`);
return; return;
} }
let newStatus: PeerPullDebitRecordStatus | undefined = undefined; let newStatus: PeerPullDebitRecordStatus | undefined = undefined;
@ -765,7 +765,7 @@ export async function failPeerPullDebitTransaction(
case PeerPullDebitRecordStatus.DialogProposed: case PeerPullDebitRecordStatus.DialogProposed:
newStatus = PeerPullDebitRecordStatus.Aborted; newStatus = PeerPullDebitRecordStatus.Aborted;
break; break;
case PeerPullDebitRecordStatus.DonePaid: case PeerPullDebitRecordStatus.Done:
break; break;
case PeerPullDebitRecordStatus.PendingDeposit: case PeerPullDebitRecordStatus.PendingDeposit:
break; break;
@ -787,7 +787,7 @@ export async function failPeerPullDebitTransaction(
const oldTxState = computePeerPullDebitTransactionState(pullDebitRec); const oldTxState = computePeerPullDebitTransactionState(pullDebitRec);
pullDebitRec.status = newStatus; pullDebitRec.status = newStatus;
const newTxState = computePeerPullDebitTransactionState(pullDebitRec); const newTxState = computePeerPullDebitTransactionState(pullDebitRec);
await tx.peerPullPaymentIncoming.put(pullDebitRec); await tx.peerPullDebit.put(pullDebitRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -800,31 +800,31 @@ export async function failPeerPullDebitTransaction(
export async function resumePeerPullDebitTransaction( export async function resumePeerPullDebitTransaction(
ws: InternalWalletState, ws: InternalWalletState,
peerPullPaymentIncomingId: string, peerPullDebitId: string,
) { ) {
const taskId = constructTaskIdentifier({ const taskId = constructTaskIdentifier({
tag: PendingTaskType.PeerPullDebit, tag: PendingTaskType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId, peerPullDebitId,
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pullDebitRec = await tx.peerPullPaymentIncoming.get( const pullDebitRec = await tx.peerPullDebit.get(
peerPullPaymentIncomingId, peerPullDebitId,
); );
if (!pullDebitRec) { if (!pullDebitRec) {
logger.warn(`peer pull debit ${peerPullPaymentIncomingId} not found`); logger.warn(`peer pull debit ${peerPullDebitId} not found`);
return; return;
} }
let newStatus: PeerPullDebitRecordStatus | undefined = undefined; let newStatus: PeerPullDebitRecordStatus | undefined = undefined;
switch (pullDebitRec.status) { switch (pullDebitRec.status) {
case PeerPullDebitRecordStatus.DialogProposed: case PeerPullDebitRecordStatus.DialogProposed:
case PeerPullDebitRecordStatus.DonePaid: case PeerPullDebitRecordStatus.Done:
case PeerPullDebitRecordStatus.PendingDeposit: case PeerPullDebitRecordStatus.PendingDeposit:
break; break;
case PeerPullDebitRecordStatus.SuspendedDeposit: case PeerPullDebitRecordStatus.SuspendedDeposit:
@ -846,7 +846,7 @@ export async function resumePeerPullDebitTransaction(
const oldTxState = computePeerPullDebitTransactionState(pullDebitRec); const oldTxState = computePeerPullDebitTransactionState(pullDebitRec);
pullDebitRec.status = newStatus; pullDebitRec.status = newStatus;
const newTxState = computePeerPullDebitTransactionState(pullDebitRec); const newTxState = computePeerPullDebitTransactionState(pullDebitRec);
await tx.peerPullPaymentIncoming.put(pullDebitRec); await tx.peerPullDebit.put(pullDebitRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -872,7 +872,7 @@ export function computePeerPullDebitTransactionState(
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.Deposit, minor: TransactionMinorState.Deposit,
}; };
case PeerPullDebitRecordStatus.DonePaid: case PeerPullDebitRecordStatus.Done:
return { return {
major: TransactionMajorState.Done, major: TransactionMajorState.Done,
}; };
@ -910,7 +910,7 @@ export function computePeerPullDebitTransactionActions(
return []; return [];
case PeerPullDebitRecordStatus.PendingDeposit: case PeerPullDebitRecordStatus.PendingDeposit:
return [TransactionAction.Abort, TransactionAction.Suspend]; return [TransactionAction.Abort, TransactionAction.Suspend];
case PeerPullDebitRecordStatus.DonePaid: case PeerPullDebitRecordStatus.Done:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PeerPullDebitRecordStatus.SuspendedDeposit: case PeerPullDebitRecordStatus.SuspendedDeposit:
return [TransactionAction.Resume, TransactionAction.Abort]; return [TransactionAction.Resume, TransactionAction.Abort];

314
packages/taler-wallet-core/src/operations/pay-peer-push-credit.ts
View File

@ -55,7 +55,7 @@ import {
KycPendingInfo, KycPendingInfo,
KycUserType, KycUserType,
PeerPushPaymentIncomingRecord, PeerPushPaymentIncomingRecord,
PeerPushPaymentIncomingStatus, PeerPushCreditStatus,
PendingTaskType, PendingTaskType,
WithdrawalGroupStatus, WithdrawalGroupStatus,
WithdrawalRecordType, WithdrawalRecordType,
@ -99,10 +99,10 @@ export async function preparePeerPushCredit(
} }
const existing = await ws.db const existing = await ws.db
.mktx((x) => [x.contractTerms, x.peerPushPaymentIncoming]) .mktx((x) => [x.contractTerms, x.peerPushCredit])
.runReadOnly(async (tx) => { .runReadOnly(async (tx) => {
const existingPushInc = const existingPushInc =
await tx.peerPushPaymentIncoming.indexes.byExchangeAndContractPriv.get([ await tx.peerPushCredit.indexes.byExchangeAndContractPriv.get([
uri.exchangeBaseUrl, uri.exchangeBaseUrl,
uri.contractPriv, uri.contractPriv,
]); ]);
@ -129,12 +129,12 @@ export async function preparePeerPushCredit(
amountEffective: existing.existingPushInc.estimatedAmountEffective, amountEffective: existing.existingPushInc.estimatedAmountEffective,
amountRaw: existing.existingContractTerms.amount, amountRaw: existing.existingContractTerms.amount,
contractTerms: existing.existingContractTerms, contractTerms: existing.existingContractTerms,
peerPushPaymentIncomingId: peerPushCreditId:
existing.existingPushInc.peerPushPaymentIncomingId, existing.existingPushInc.peerPushCreditId,
transactionId: constructTransactionIdentifier({ transactionId: constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId: peerPushCreditId:
existing.existingPushInc.peerPushPaymentIncomingId, existing.existingPushInc.peerPushCreditId,
}), }),
}; };
} }
@ -172,7 +172,7 @@ export async function preparePeerPushCredit(
codecForExchangePurseStatus(), codecForExchangePurseStatus(),
); );
const peerPushPaymentIncomingId = encodeCrock(getRandomBytes(32)); const peerPushCreditId = encodeCrock(getRandomBytes(32));
const contractTermsHash = ContractTermsUtil.hashContractTerms( const contractTermsHash = ContractTermsUtil.hashContractTerms(
dec.contractTerms, dec.contractTerms,
@ -188,17 +188,17 @@ export async function preparePeerPushCredit(
); );
await ws.db await ws.db
.mktx((x) => [x.contractTerms, x.peerPushPaymentIncoming]) .mktx((x) => [x.contractTerms, x.peerPushCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
await tx.peerPushPaymentIncoming.add({ await tx.peerPushCredit.add({
peerPushPaymentIncomingId, peerPushCreditId,
contractPriv: contractPriv, contractPriv: contractPriv,
exchangeBaseUrl: exchangeBaseUrl, exchangeBaseUrl: exchangeBaseUrl,
mergePriv: dec.mergePriv, mergePriv: dec.mergePriv,
pursePub: pursePub, pursePub: pursePub,
timestamp: TalerPreciseTimestamp.now(), timestamp: TalerPreciseTimestamp.now(),
contractTermsHash, contractTermsHash,
status: PeerPushPaymentIncomingStatus.DialogProposed, status: PeerPushCreditStatus.DialogProposed,
withdrawalGroupId, withdrawalGroupId,
currency: Amounts.currencyOf(purseStatus.balance), currency: Amounts.currencyOf(purseStatus.balance),
estimatedAmountEffective: Amounts.stringify( estimatedAmountEffective: Amounts.stringify(
@ -219,28 +219,28 @@ export async function preparePeerPushCredit(
amountEffective: wi.withdrawalAmountEffective, amountEffective: wi.withdrawalAmountEffective,
amountRaw: purseStatus.balance, amountRaw: purseStatus.balance,
contractTerms: dec.contractTerms, contractTerms: dec.contractTerms,
peerPushPaymentIncomingId, peerPushCreditId,
transactionId: constructTransactionIdentifier({ transactionId: constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}), }),
}; };
} }
async function longpollKycStatus( async function longpollKycStatus(
ws: InternalWalletState, ws: InternalWalletState,
peerPushPaymentIncomingId: string, peerPushCreditId: string,
exchangeUrl: string, exchangeUrl: string,
kycInfo: KycPendingInfo, kycInfo: KycPendingInfo,
userType: KycUserType, userType: KycUserType,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}); });
const retryTag = constructTaskIdentifier({ const retryTag = constructTaskIdentifier({
tag: PendingTaskType.PeerPushCredit, tag: PendingTaskType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}); });
runLongpollAsync(ws, retryTag, async (ct) => { runLongpollAsync(ws, retryTag, async (ct) => {
@ -261,24 +261,24 @@ async function longpollKycStatus(
kycStatusRes.status === HttpStatusCode.NoContent kycStatusRes.status === HttpStatusCode.NoContent
) { ) {
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPushPaymentIncoming]) .mktx((x) => [x.peerPushCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const peerInc = await tx.peerPushPaymentIncoming.get( const peerInc = await tx.peerPushCredit.get(
peerPushPaymentIncomingId, peerPushCreditId,
); );
if (!peerInc) { if (!peerInc) {
return; return;
} }
if ( if (
peerInc.status !== peerInc.status !==
PeerPushPaymentIncomingStatus.PendingMergeKycRequired PeerPushCreditStatus.PendingMergeKycRequired
) { ) {
return; return;
} }
const oldTxState = computePeerPushCreditTransactionState(peerInc); const oldTxState = computePeerPushCreditTransactionState(peerInc);
peerInc.status = PeerPushPaymentIncomingStatus.PendingMerge; peerInc.status = PeerPushCreditStatus.PendingMerge;
const newTxState = computePeerPushCreditTransactionState(peerInc); const newTxState = computePeerPushCreditTransactionState(peerInc);
await tx.peerPushPaymentIncoming.put(peerInc); await tx.peerPushCredit.put(peerInc);
return { oldTxState, newTxState }; return { oldTxState, newTxState };
}); });
notifyTransition(ws, transactionId, transitionInfo); notifyTransition(ws, transactionId, transitionInfo);
@ -304,9 +304,9 @@ async function processPeerPushCreditKycRequired(
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId: peerInc.peerPushPaymentIncomingId, peerPushCreditId: peerInc.peerPushCreditId,
}); });
const { peerPushPaymentIncomingId } = peerInc; const { peerPushCreditId } = peerInc;
const userType = "individual"; const userType = "individual";
const url = new URL( const url = new URL(
@ -331,10 +331,10 @@ async function processPeerPushCreditKycRequired(
const kycStatus = await kycStatusRes.json(); const kycStatus = await kycStatusRes.json();
logger.info(`kyc status: ${j2s(kycStatus)}`); logger.info(`kyc status: ${j2s(kycStatus)}`);
const { transitionInfo, result } = await ws.db const { transitionInfo, result } = await ws.db
.mktx((x) => [x.peerPushPaymentIncoming]) .mktx((x) => [x.peerPushCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const peerInc = await tx.peerPushPaymentIncoming.get( const peerInc = await tx.peerPushCredit.get(
peerPushPaymentIncomingId, peerPushCreditId,
); );
if (!peerInc) { if (!peerInc) {
return { return {
@ -348,9 +348,9 @@ async function processPeerPushCreditKycRequired(
requirementRow: kycPending.requirement_row, requirementRow: kycPending.requirement_row,
}; };
peerInc.kycUrl = kycStatus.kyc_url; peerInc.kycUrl = kycStatus.kyc_url;
peerInc.status = PeerPushPaymentIncomingStatus.PendingMergeKycRequired; peerInc.status = PeerPushCreditStatus.PendingMergeKycRequired;
const newTxState = computePeerPushCreditTransactionState(peerInc); const newTxState = computePeerPushCreditTransactionState(peerInc);
await tx.peerPushPaymentIncoming.put(peerInc); await tx.peerPushCredit.put(peerInc);
// We'll remove this eventually! New clients should rely on the // We'll remove this eventually! New clients should rely on the
// kycUrl field of the transaction, not the error code. // kycUrl field of the transaction, not the error code.
const res: TaskRunResult = { const res: TaskRunResult = {
@ -379,10 +379,10 @@ async function handlePendingMerge(
peerInc: PeerPushPaymentIncomingRecord, peerInc: PeerPushPaymentIncomingRecord,
contractTerms: PeerContractTerms, contractTerms: PeerContractTerms,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const { peerPushPaymentIncomingId } = peerInc; const { peerPushCreditId } = peerInc;
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}); });
const amount = Amounts.parseOrThrow(contractTerms.amount); const amount = Amounts.parseOrThrow(contractTerms.amount);
@ -460,15 +460,15 @@ async function handlePendingMerge(
const txRes = await ws.db const txRes = await ws.db
.mktx((x) => [ .mktx((x) => [
x.contractTerms, x.contractTerms,
x.peerPushPaymentIncoming, x.peerPushCredit,
x.withdrawalGroups, x.withdrawalGroups,
x.reserves, x.reserves,
x.exchanges, x.exchanges,
x.exchangeDetails, x.exchangeDetails,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const peerInc = await tx.peerPushPaymentIncoming.get( const peerInc = await tx.peerPushCredit.get(
peerPushPaymentIncomingId, peerPushCreditId,
); );
if (!peerInc) { if (!peerInc) {
return undefined; return undefined;
@ -476,9 +476,9 @@ async function handlePendingMerge(
let withdrawalTransition: TransitionInfo | undefined; let withdrawalTransition: TransitionInfo | undefined;
const oldTxState = computePeerPushCreditTransactionState(peerInc); const oldTxState = computePeerPushCreditTransactionState(peerInc);
switch (peerInc.status) { switch (peerInc.status) {
case PeerPushPaymentIncomingStatus.PendingMerge: case PeerPushCreditStatus.PendingMerge:
case PeerPushPaymentIncomingStatus.PendingMergeKycRequired: { case PeerPushCreditStatus.PendingMergeKycRequired: {
peerInc.status = PeerPushPaymentIncomingStatus.PendingWithdrawing; peerInc.status = PeerPushCreditStatus.PendingWithdrawing;
const wgRes = await internalPerformCreateWithdrawalGroup( const wgRes = await internalPerformCreateWithdrawalGroup(
ws, ws,
tx, tx,
@ -488,7 +488,7 @@ async function handlePendingMerge(
break; break;
} }
} }
await tx.peerPushPaymentIncoming.put(peerInc); await tx.peerPushCredit.put(peerInc);
const newTxState = computePeerPushCreditTransactionState(peerInc); const newTxState = computePeerPushCreditTransactionState(peerInc);
return { return {
peerPushCreditTransition: { oldTxState, newTxState }, peerPushCreditTransition: { oldTxState, newTxState },
@ -514,21 +514,21 @@ async function handlePendingWithdrawing(
} }
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId: peerInc.peerPushPaymentIncomingId, peerPushCreditId: peerInc.peerPushCreditId,
}); });
const wgId = peerInc.withdrawalGroupId; const wgId = peerInc.withdrawalGroupId;
let finished: boolean = false; let finished: boolean = false;
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPushPaymentIncoming, x.withdrawalGroups]) .mktx((x) => [x.peerPushCredit, x.withdrawalGroups])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const ppi = await tx.peerPushPaymentIncoming.get( const ppi = await tx.peerPushCredit.get(
peerInc.peerPushPaymentIncomingId, peerInc.peerPushCreditId,
); );
if (!ppi) { if (!ppi) {
finished = true; finished = true;
return; return;
} }
if (ppi.status !== PeerPushPaymentIncomingStatus.PendingWithdrawing) { if (ppi.status !== PeerPushCreditStatus.PendingWithdrawing) {
finished = true; finished = true;
return; return;
} }
@ -539,13 +539,13 @@ async function handlePendingWithdrawing(
return undefined; return undefined;
} }
switch (wg.status) { switch (wg.status) {
case WithdrawalGroupStatus.Finished: case WithdrawalGroupStatus.Done:
finished = true; finished = true;
ppi.status = PeerPushPaymentIncomingStatus.Done; ppi.status = PeerPushCreditStatus.Done;
break; break;
// FIXME: Also handle other final states! // FIXME: Also handle other final states!
} }
await tx.peerPushPaymentIncoming.put(ppi); await tx.peerPushCredit.put(ppi);
const newTxState = computePeerPushCreditTransactionState(ppi); const newTxState = computePeerPushCreditTransactionState(ppi);
return { return {
oldTxState, oldTxState,
@ -563,14 +563,14 @@ async function handlePendingWithdrawing(
export async function processPeerPushCredit( export async function processPeerPushCredit(
ws: InternalWalletState, ws: InternalWalletState,
peerPushPaymentIncomingId: string, peerPushCreditId: string,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
let peerInc: PeerPushPaymentIncomingRecord | undefined; let peerInc: PeerPushPaymentIncomingRecord | undefined;
let contractTerms: PeerContractTerms | undefined; let contractTerms: PeerContractTerms | undefined;
await ws.db await ws.db
.mktx((x) => [x.contractTerms, x.peerPushPaymentIncoming]) .mktx((x) => [x.contractTerms, x.peerPushCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
peerInc = await tx.peerPushPaymentIncoming.get(peerPushPaymentIncomingId); peerInc = await tx.peerPushCredit.get(peerPushCreditId);
if (!peerInc) { if (!peerInc) {
return; return;
} }
@ -578,35 +578,35 @@ export async function processPeerPushCredit(
if (ctRec) { if (ctRec) {
contractTerms = ctRec.contractTermsRaw; contractTerms = ctRec.contractTermsRaw;
} }
await tx.peerPushPaymentIncoming.put(peerInc); await tx.peerPushCredit.put(peerInc);
}); });
checkDbInvariant(!!contractTerms); checkDbInvariant(!!contractTerms);
if (!peerInc) { if (!peerInc) {
throw Error( throw Error(
`can't accept unknown incoming p2p push payment (${peerPushPaymentIncomingId})`, `can't accept unknown incoming p2p push payment (${peerPushCreditId})`,
); );
} }
switch (peerInc.status) { switch (peerInc.status) {
case PeerPushPaymentIncomingStatus.PendingMergeKycRequired: { case PeerPushCreditStatus.PendingMergeKycRequired: {
if (!peerInc.kycInfo) { if (!peerInc.kycInfo) {
throw Error("invalid state, kycInfo required"); throw Error("invalid state, kycInfo required");
} }
return await longpollKycStatus( return await longpollKycStatus(
ws, ws,
peerPushPaymentIncomingId, peerPushCreditId,
peerInc.exchangeBaseUrl, peerInc.exchangeBaseUrl,
peerInc.kycInfo, peerInc.kycInfo,
"individual", "individual",
); );
} }
case PeerPushPaymentIncomingStatus.PendingMerge: case PeerPushCreditStatus.PendingMerge:
return handlePendingMerge(ws, peerInc, contractTerms); return handlePendingMerge(ws, peerInc, contractTerms);
case PeerPushPaymentIncomingStatus.PendingWithdrawing: case PeerPushCreditStatus.PendingWithdrawing:
return handlePendingWithdrawing(ws, peerInc); return handlePendingWithdrawing(ws, peerInc);
default: default:
@ -619,9 +619,9 @@ export async function confirmPeerPushCredit(
req: ConfirmPeerPushCreditRequest, req: ConfirmPeerPushCreditRequest,
): Promise<AcceptPeerPushPaymentResponse> { ): Promise<AcceptPeerPushPaymentResponse> {
let peerInc: PeerPushPaymentIncomingRecord | undefined; let peerInc: PeerPushPaymentIncomingRecord | undefined;
let peerPushPaymentIncomingId: string; let peerPushCreditId: string;
if (req.peerPushPaymentIncomingId) { if (req.peerPushCreditId) {
peerPushPaymentIncomingId = req.peerPushPaymentIncomingId; peerPushCreditId = req.peerPushCreditId;
} else if (req.transactionId) { } else if (req.transactionId) {
const parsedTx = parseTransactionIdentifier(req.transactionId); const parsedTx = parseTransactionIdentifier(req.transactionId);
if (!parsedTx) { if (!parsedTx) {
@ -630,29 +630,29 @@ export async function confirmPeerPushCredit(
if (parsedTx.tag !== TransactionType.PeerPushCredit) { if (parsedTx.tag !== TransactionType.PeerPushCredit) {
throw Error("invalid transaction ID type"); throw Error("invalid transaction ID type");
} }
peerPushPaymentIncomingId = parsedTx.peerPushPaymentIncomingId; peerPushCreditId = parsedTx.peerPushCreditId;
} else { } else {
throw Error( throw Error(
"no transaction ID (or deprecated peerPushPaymentIncomingId) provided", "no transaction ID (or deprecated peerPushCreditId) provided",
); );
} }
await ws.db await ws.db
.mktx((x) => [x.contractTerms, x.peerPushPaymentIncoming]) .mktx((x) => [x.contractTerms, x.peerPushCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
peerInc = await tx.peerPushPaymentIncoming.get(peerPushPaymentIncomingId); peerInc = await tx.peerPushCredit.get(peerPushCreditId);
if (!peerInc) { if (!peerInc) {
return; return;
} }
if (peerInc.status === PeerPushPaymentIncomingStatus.DialogProposed) { if (peerInc.status === PeerPushCreditStatus.DialogProposed) {
peerInc.status = PeerPushPaymentIncomingStatus.PendingMerge; peerInc.status = PeerPushCreditStatus.PendingMerge;
} }
await tx.peerPushPaymentIncoming.put(peerInc); await tx.peerPushCredit.put(peerInc);
}); });
if (!peerInc) { if (!peerInc) {
throw Error( throw Error(
`can't accept unknown incoming p2p push payment (${req.peerPushPaymentIncomingId})`, `can't accept unknown incoming p2p push payment (${req.peerPushCreditId})`,
); );
} }
@ -660,7 +660,7 @@ export async function confirmPeerPushCredit(
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}); });
return { return {
@ -670,48 +670,48 @@ export async function confirmPeerPushCredit(
export async function suspendPeerPushCreditTransaction( export async function suspendPeerPushCreditTransaction(
ws: InternalWalletState, ws: InternalWalletState,
peerPushPaymentIncomingId: string, peerPushCreditId: string,
) { ) {
const taskId = constructTaskIdentifier({ const taskId = constructTaskIdentifier({
tag: PendingTaskType.PeerPushCredit, tag: PendingTaskType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}); });
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPushPaymentIncoming]) .mktx((x) => [x.peerPushCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pushCreditRec = await tx.peerPushPaymentIncoming.get( const pushCreditRec = await tx.peerPushCredit.get(
peerPushPaymentIncomingId, peerPushCreditId,
); );
if (!pushCreditRec) { if (!pushCreditRec) {
logger.warn(`peer push credit ${peerPushPaymentIncomingId} not found`); logger.warn(`peer push credit ${peerPushCreditId} not found`);
return; return;
} }
let newStatus: PeerPushPaymentIncomingStatus | undefined = undefined; let newStatus: PeerPushCreditStatus | undefined = undefined;
switch (pushCreditRec.status) { switch (pushCreditRec.status) {
case PeerPushPaymentIncomingStatus.DialogProposed: case PeerPushCreditStatus.DialogProposed:
case PeerPushPaymentIncomingStatus.Done: case PeerPushCreditStatus.Done:
case PeerPushPaymentIncomingStatus.SuspendedMerge: case PeerPushCreditStatus.SuspendedMerge:
case PeerPushPaymentIncomingStatus.SuspendedMergeKycRequired: case PeerPushCreditStatus.SuspendedMergeKycRequired:
case PeerPushPaymentIncomingStatus.SuspendedWithdrawing: case PeerPushCreditStatus.SuspendedWithdrawing:
break; break;
case PeerPushPaymentIncomingStatus.PendingMergeKycRequired: case PeerPushCreditStatus.PendingMergeKycRequired:
newStatus = PeerPushPaymentIncomingStatus.SuspendedMergeKycRequired; newStatus = PeerPushCreditStatus.SuspendedMergeKycRequired;
break; break;
case PeerPushPaymentIncomingStatus.PendingMerge: case PeerPushCreditStatus.PendingMerge:
newStatus = PeerPushPaymentIncomingStatus.SuspendedMerge; newStatus = PeerPushCreditStatus.SuspendedMerge;
break; break;
case PeerPushPaymentIncomingStatus.PendingWithdrawing: case PeerPushCreditStatus.PendingWithdrawing:
// FIXME: Suspend internal withdrawal transaction! // FIXME: Suspend internal withdrawal transaction!
newStatus = PeerPushPaymentIncomingStatus.SuspendedWithdrawing; newStatus = PeerPushCreditStatus.SuspendedWithdrawing;
break; break;
case PeerPushPaymentIncomingStatus.Aborted: case PeerPushCreditStatus.Aborted:
break; break;
case PeerPushPaymentIncomingStatus.Failed: case PeerPushCreditStatus.Failed:
break; break;
default: default:
assertUnreachable(pushCreditRec.status); assertUnreachable(pushCreditRec.status);
@ -720,7 +720,7 @@ export async function suspendPeerPushCreditTransaction(
const oldTxState = computePeerPushCreditTransactionState(pushCreditRec); const oldTxState = computePeerPushCreditTransactionState(pushCreditRec);
pushCreditRec.status = newStatus; pushCreditRec.status = newStatus;
const newTxState = computePeerPushCreditTransactionState(pushCreditRec); const newTxState = computePeerPushCreditTransactionState(pushCreditRec);
await tx.peerPushPaymentIncoming.put(pushCreditRec); await tx.peerPushCredit.put(pushCreditRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -733,51 +733,51 @@ export async function suspendPeerPushCreditTransaction(
export async function abortPeerPushCreditTransaction( export async function abortPeerPushCreditTransaction(
ws: InternalWalletState, ws: InternalWalletState,
peerPushPaymentIncomingId: string, peerPushCreditId: string,
) { ) {
const taskId = constructTaskIdentifier({ const taskId = constructTaskIdentifier({
tag: PendingTaskType.PeerPushCredit, tag: PendingTaskType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}); });
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPushPaymentIncoming]) .mktx((x) => [x.peerPushCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pushCreditRec = await tx.peerPushPaymentIncoming.get( const pushCreditRec = await tx.peerPushCredit.get(
peerPushPaymentIncomingId, peerPushCreditId,
); );
if (!pushCreditRec) { if (!pushCreditRec) {
logger.warn(`peer push credit ${peerPushPaymentIncomingId} not found`); logger.warn(`peer push credit ${peerPushCreditId} not found`);
return; return;
} }
let newStatus: PeerPushPaymentIncomingStatus | undefined = undefined; let newStatus: PeerPushCreditStatus | undefined = undefined;
switch (pushCreditRec.status) { switch (pushCreditRec.status) {
case PeerPushPaymentIncomingStatus.DialogProposed: case PeerPushCreditStatus.DialogProposed:
newStatus = PeerPushPaymentIncomingStatus.Aborted; newStatus = PeerPushCreditStatus.Aborted;
break; break;
case PeerPushPaymentIncomingStatus.Done: case PeerPushCreditStatus.Done:
break; break;
case PeerPushPaymentIncomingStatus.SuspendedMerge: case PeerPushCreditStatus.SuspendedMerge:
case PeerPushPaymentIncomingStatus.SuspendedMergeKycRequired: case PeerPushCreditStatus.SuspendedMergeKycRequired:
case PeerPushPaymentIncomingStatus.SuspendedWithdrawing: case PeerPushCreditStatus.SuspendedWithdrawing:
newStatus = PeerPushPaymentIncomingStatus.Aborted; newStatus = PeerPushCreditStatus.Aborted;
break; break;
case PeerPushPaymentIncomingStatus.PendingMergeKycRequired: case PeerPushCreditStatus.PendingMergeKycRequired:
newStatus = PeerPushPaymentIncomingStatus.Aborted; newStatus = PeerPushCreditStatus.Aborted;
break; break;
case PeerPushPaymentIncomingStatus.PendingMerge: case PeerPushCreditStatus.PendingMerge:
newStatus = PeerPushPaymentIncomingStatus.Aborted; newStatus = PeerPushCreditStatus.Aborted;
break; break;
case PeerPushPaymentIncomingStatus.PendingWithdrawing: case PeerPushCreditStatus.PendingWithdrawing:
newStatus = PeerPushPaymentIncomingStatus.Aborted; newStatus = PeerPushCreditStatus.Aborted;
break; break;
case PeerPushPaymentIncomingStatus.Aborted: case PeerPushCreditStatus.Aborted:
break; break;
case PeerPushPaymentIncomingStatus.Failed: case PeerPushCreditStatus.Failed:
break; break;
default: default:
assertUnreachable(pushCreditRec.status); assertUnreachable(pushCreditRec.status);
@ -786,7 +786,7 @@ export async function abortPeerPushCreditTransaction(
const oldTxState = computePeerPushCreditTransactionState(pushCreditRec); const oldTxState = computePeerPushCreditTransactionState(pushCreditRec);
pushCreditRec.status = newStatus; pushCreditRec.status = newStatus;
const newTxState = computePeerPushCreditTransactionState(pushCreditRec); const newTxState = computePeerPushCreditTransactionState(pushCreditRec);
await tx.peerPushPaymentIncoming.put(pushCreditRec); await tx.peerPushCredit.put(pushCreditRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -799,7 +799,7 @@ export async function abortPeerPushCreditTransaction(
export async function failPeerPushCreditTransaction( export async function failPeerPushCreditTransaction(
ws: InternalWalletState, ws: InternalWalletState,
peerPushPaymentIncomingId: string, peerPushCreditId: string,
) { ) {
// We don't have any "aborting" states! // We don't have any "aborting" states!
throw Error("can't run cancel-aborting on peer-push-credit transaction"); throw Error("can't run cancel-aborting on peer-push-credit transaction");
@ -807,47 +807,47 @@ export async function failPeerPushCreditTransaction(
export async function resumePeerPushCreditTransaction( export async function resumePeerPushCreditTransaction(
ws: InternalWalletState, ws: InternalWalletState,
peerPushPaymentIncomingId: string, peerPushCreditId: string,
) { ) {
const taskId = constructTaskIdentifier({ const taskId = constructTaskIdentifier({
tag: PendingTaskType.PeerPushCredit, tag: PendingTaskType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}); });
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId, peerPushCreditId,
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPushPaymentIncoming]) .mktx((x) => [x.peerPushCredit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pushCreditRec = await tx.peerPushPaymentIncoming.get( const pushCreditRec = await tx.peerPushCredit.get(
peerPushPaymentIncomingId, peerPushCreditId,
); );
if (!pushCreditRec) { if (!pushCreditRec) {
logger.warn(`peer push credit ${peerPushPaymentIncomingId} not found`); logger.warn(`peer push credit ${peerPushCreditId} not found`);
return; return;
} }
let newStatus: PeerPushPaymentIncomingStatus | undefined = undefined; let newStatus: PeerPushCreditStatus | undefined = undefined;
switch (pushCreditRec.status) { switch (pushCreditRec.status) {
case PeerPushPaymentIncomingStatus.DialogProposed: case PeerPushCreditStatus.DialogProposed:
case PeerPushPaymentIncomingStatus.Done: case PeerPushCreditStatus.Done:
case PeerPushPaymentIncomingStatus.PendingMergeKycRequired: case PeerPushCreditStatus.PendingMergeKycRequired:
case PeerPushPaymentIncomingStatus.PendingMerge: case PeerPushCreditStatus.PendingMerge:
case PeerPushPaymentIncomingStatus.PendingWithdrawing: case PeerPushCreditStatus.PendingWithdrawing:
case PeerPushPaymentIncomingStatus.SuspendedMerge: case PeerPushCreditStatus.SuspendedMerge:
newStatus = PeerPushPaymentIncomingStatus.PendingMerge; newStatus = PeerPushCreditStatus.PendingMerge;
break; break;
case PeerPushPaymentIncomingStatus.SuspendedMergeKycRequired: case PeerPushCreditStatus.SuspendedMergeKycRequired:
newStatus = PeerPushPaymentIncomingStatus.PendingMergeKycRequired; newStatus = PeerPushCreditStatus.PendingMergeKycRequired;
break; break;
case PeerPushPaymentIncomingStatus.SuspendedWithdrawing: case PeerPushCreditStatus.SuspendedWithdrawing:
// FIXME: resume underlying "internal-withdrawal" transaction. // FIXME: resume underlying "internal-withdrawal" transaction.
newStatus = PeerPushPaymentIncomingStatus.PendingWithdrawing; newStatus = PeerPushCreditStatus.PendingWithdrawing;
break; break;
case PeerPushPaymentIncomingStatus.Aborted: case PeerPushCreditStatus.Aborted:
break; break;
case PeerPushPaymentIncomingStatus.Failed: case PeerPushCreditStatus.Failed:
break; break;
default: default:
assertUnreachable(pushCreditRec.status); assertUnreachable(pushCreditRec.status);
@ -856,7 +856,7 @@ export async function resumePeerPushCreditTransaction(
const oldTxState = computePeerPushCreditTransactionState(pushCreditRec); const oldTxState = computePeerPushCreditTransactionState(pushCreditRec);
pushCreditRec.status = newStatus; pushCreditRec.status = newStatus;
const newTxState = computePeerPushCreditTransactionState(pushCreditRec); const newTxState = computePeerPushCreditTransactionState(pushCreditRec);
await tx.peerPushPaymentIncoming.put(pushCreditRec); await tx.peerPushCredit.put(pushCreditRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -872,50 +872,50 @@ export function computePeerPushCreditTransactionState(
pushCreditRecord: PeerPushPaymentIncomingRecord, pushCreditRecord: PeerPushPaymentIncomingRecord,
): TransactionState { ): TransactionState {
switch (pushCreditRecord.status) { switch (pushCreditRecord.status) {
case PeerPushPaymentIncomingStatus.DialogProposed: case PeerPushCreditStatus.DialogProposed:
return { return {
major: TransactionMajorState.Dialog, major: TransactionMajorState.Dialog,
minor: TransactionMinorState.Proposed, minor: TransactionMinorState.Proposed,
}; };
case PeerPushPaymentIncomingStatus.PendingMerge: case PeerPushCreditStatus.PendingMerge:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.Merge, minor: TransactionMinorState.Merge,
}; };
case PeerPushPaymentIncomingStatus.Done: case PeerPushCreditStatus.Done:
return { return {
major: TransactionMajorState.Done, major: TransactionMajorState.Done,
}; };
case PeerPushPaymentIncomingStatus.PendingMergeKycRequired: case PeerPushCreditStatus.PendingMergeKycRequired:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.KycRequired, minor: TransactionMinorState.KycRequired,
}; };
case PeerPushPaymentIncomingStatus.PendingWithdrawing: case PeerPushCreditStatus.PendingWithdrawing:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.Withdraw, minor: TransactionMinorState.Withdraw,
}; };
case PeerPushPaymentIncomingStatus.SuspendedMerge: case PeerPushCreditStatus.SuspendedMerge:
return { return {
major: TransactionMajorState.Suspended, major: TransactionMajorState.Suspended,
minor: TransactionMinorState.Merge, minor: TransactionMinorState.Merge,
}; };
case PeerPushPaymentIncomingStatus.SuspendedMergeKycRequired: case PeerPushCreditStatus.SuspendedMergeKycRequired:
return { return {
major: TransactionMajorState.Suspended, major: TransactionMajorState.Suspended,
minor: TransactionMinorState.MergeKycRequired, minor: TransactionMinorState.MergeKycRequired,
}; };
case PeerPushPaymentIncomingStatus.SuspendedWithdrawing: case PeerPushCreditStatus.SuspendedWithdrawing:
return { return {
major: TransactionMajorState.Suspended, major: TransactionMajorState.Suspended,
minor: TransactionMinorState.Withdraw, minor: TransactionMinorState.Withdraw,
}; };
case PeerPushPaymentIncomingStatus.Aborted: case PeerPushCreditStatus.Aborted:
return { return {
major: TransactionMajorState.Aborted, major: TransactionMajorState.Aborted,
}; };
case PeerPushPaymentIncomingStatus.Failed: case PeerPushCreditStatus.Failed:
return { return {
major: TransactionMajorState.Failed, major: TransactionMajorState.Failed,
}; };
@ -928,25 +928,25 @@ export function computePeerPushCreditTransactionActions(
pushCreditRecord: PeerPushPaymentIncomingRecord, pushCreditRecord: PeerPushPaymentIncomingRecord,
): TransactionAction[] { ): TransactionAction[] {
switch (pushCreditRecord.status) { switch (pushCreditRecord.status) {
case PeerPushPaymentIncomingStatus.DialogProposed: case PeerPushCreditStatus.DialogProposed:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PeerPushPaymentIncomingStatus.PendingMerge: case PeerPushCreditStatus.PendingMerge:
return [TransactionAction.Abort, TransactionAction.Suspend]; return [TransactionAction.Abort, TransactionAction.Suspend];
case PeerPushPaymentIncomingStatus.Done: case PeerPushCreditStatus.Done:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PeerPushPaymentIncomingStatus.PendingMergeKycRequired: case PeerPushCreditStatus.PendingMergeKycRequired:
return [TransactionAction.Abort, TransactionAction.Suspend]; return [TransactionAction.Abort, TransactionAction.Suspend];
case PeerPushPaymentIncomingStatus.PendingWithdrawing: case PeerPushCreditStatus.PendingWithdrawing:
return [TransactionAction.Suspend, TransactionAction.Fail]; return [TransactionAction.Suspend, TransactionAction.Fail];
case PeerPushPaymentIncomingStatus.SuspendedMerge: case PeerPushCreditStatus.SuspendedMerge:
return [TransactionAction.Resume, TransactionAction.Abort]; return [TransactionAction.Resume, TransactionAction.Abort];
case PeerPushPaymentIncomingStatus.SuspendedMergeKycRequired: case PeerPushCreditStatus.SuspendedMergeKycRequired:
return [TransactionAction.Resume, TransactionAction.Abort]; return [TransactionAction.Resume, TransactionAction.Abort];
case PeerPushPaymentIncomingStatus.SuspendedWithdrawing: case PeerPushCreditStatus.SuspendedWithdrawing:
return [TransactionAction.Resume, TransactionAction.Fail]; return [TransactionAction.Resume, TransactionAction.Fail];
case PeerPushPaymentIncomingStatus.Aborted: case PeerPushCreditStatus.Aborted:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PeerPushPaymentIncomingStatus.Failed: case PeerPushCreditStatus.Failed:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
default: default:
assertUnreachable(pushCreditRecord.status); assertUnreachable(pushCreditRecord.status);

294
packages/taler-wallet-core/src/operations/pay-peer-push-debit.ts
View File

@ -51,8 +51,8 @@ import {
} from "@gnu-taler/taler-util/http"; } from "@gnu-taler/taler-util/http";
import { EncryptContractRequest } from "../crypto/cryptoTypes.js"; import { EncryptContractRequest } from "../crypto/cryptoTypes.js";
import { import {
PeerPushPaymentInitiationRecord, PeerPushDebitRecord,
PeerPushPaymentInitiationStatus, PeerPushDebitStatus,
RefreshOperationStatus, RefreshOperationStatus,
createRefreshGroup, createRefreshGroup,
} from "../index.js"; } from "../index.js";
@ -107,7 +107,7 @@ export async function checkPeerPushDebit(
async function handlePurseCreationConflict( async function handlePurseCreationConflict(
ws: InternalWalletState, ws: InternalWalletState,
peerPushInitiation: PeerPushPaymentInitiationRecord, peerPushInitiation: PeerPushDebitRecord,
resp: HttpResponse, resp: HttpResponse,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const pursePub = peerPushInitiation.pursePub; const pursePub = peerPushInitiation.pursePub;
@ -152,17 +152,17 @@ async function handlePurseCreationConflict(
} }
await ws.db await ws.db
.mktx((x) => [x.peerPushPaymentInitiations]) .mktx((x) => [x.peerPushDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const myPpi = await tx.peerPushPaymentInitiations.get( const myPpi = await tx.peerPushDebit.get(
peerPushInitiation.pursePub, peerPushInitiation.pursePub,
); );
if (!myPpi) { if (!myPpi) {
return; return;
} }
switch (myPpi.status) { switch (myPpi.status) {
case PeerPushPaymentInitiationStatus.PendingCreatePurse: case PeerPushDebitStatus.PendingCreatePurse:
case PeerPushPaymentInitiationStatus.SuspendedCreatePurse: { case PeerPushDebitStatus.SuspendedCreatePurse: {
const sel = coinSelRes.result; const sel = coinSelRes.result;
myPpi.coinSel = { myPpi.coinSel = {
coinPubs: sel.coins.map((x) => x.coinPub), coinPubs: sel.coins.map((x) => x.coinPub),
@ -173,14 +173,14 @@ async function handlePurseCreationConflict(
default: default:
return; return;
} }
await tx.peerPushPaymentInitiations.put(myPpi); await tx.peerPushDebit.put(myPpi);
}); });
return TaskRunResult.finished(); return TaskRunResult.finished();
} }
async function processPeerPushDebitCreateReserve( async function processPeerPushDebitCreateReserve(
ws: InternalWalletState, ws: InternalWalletState,
peerPushInitiation: PeerPushPaymentInitiationRecord, peerPushInitiation: PeerPushDebitRecord,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
logger.info("processing peer-push-debit pending(create-reserve)"); logger.info("processing peer-push-debit pending(create-reserve)");
const pursePub = peerPushInitiation.pursePub; const pursePub = peerPushInitiation.pursePub;
@ -284,8 +284,8 @@ async function processPeerPushDebitCreateReserve(
} }
await transitionPeerPushDebitTransaction(ws, pursePub, { await transitionPeerPushDebitTransaction(ws, pursePub, {
stFrom: PeerPushPaymentInitiationStatus.PendingCreatePurse, stFrom: PeerPushDebitStatus.PendingCreatePurse,
stTo: PeerPushPaymentInitiationStatus.PendingReady, stTo: PeerPushDebitStatus.PendingReady,
}); });
return TaskRunResult.finished(); return TaskRunResult.finished();
@ -293,7 +293,7 @@ async function processPeerPushDebitCreateReserve(
async function processPeerPushDebitAbortingDeletePurse( async function processPeerPushDebitAbortingDeletePurse(
ws: InternalWalletState, ws: InternalWalletState,
peerPushInitiation: PeerPushPaymentInitiationRecord, peerPushInitiation: PeerPushDebitRecord,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const { pursePub, pursePriv } = peerPushInitiation; const { pursePub, pursePriv } = peerPushInitiation;
const transactionId = constructTransactionIdentifier({ const transactionId = constructTransactionIdentifier({
@ -318,19 +318,19 @@ async function processPeerPushDebitAbortingDeletePurse(
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [ .mktx((x) => [
x.peerPushPaymentInitiations, x.peerPushDebit,
x.refreshGroups, x.refreshGroups,
x.denominations, x.denominations,
x.coinAvailability, x.coinAvailability,
x.coins, x.coins,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const ppiRec = await tx.peerPushPaymentInitiations.get(pursePub); const ppiRec = await tx.peerPushDebit.get(pursePub);
if (!ppiRec) { if (!ppiRec) {
return undefined; return undefined;
} }
if ( if (
ppiRec.status !== PeerPushPaymentInitiationStatus.AbortingDeletePurse ppiRec.status !== PeerPushDebitStatus.AbortingDeletePurse
) { ) {
return undefined; return undefined;
} }
@ -352,9 +352,9 @@ async function processPeerPushDebitAbortingDeletePurse(
coinPubs, coinPubs,
RefreshReason.AbortPeerPushDebit, RefreshReason.AbortPeerPushDebit,
); );
ppiRec.status = PeerPushPaymentInitiationStatus.AbortingRefresh; ppiRec.status = PeerPushDebitStatus.AbortingRefresh;
ppiRec.abortRefreshGroupId = refresh.refreshGroupId; ppiRec.abortRefreshGroupId = refresh.refreshGroupId;
await tx.peerPushPaymentInitiations.put(ppiRec); await tx.peerPushDebit.put(ppiRec);
const newTxState = computePeerPushDebitTransactionState(ppiRec); const newTxState = computePeerPushDebitTransactionState(ppiRec);
return { return {
oldTxState, oldTxState,
@ -367,8 +367,8 @@ async function processPeerPushDebitAbortingDeletePurse(
} }
interface SimpleTransition { interface SimpleTransition {
stFrom: PeerPushPaymentInitiationStatus; stFrom: PeerPushDebitStatus;
stTo: PeerPushPaymentInitiationStatus; stTo: PeerPushDebitStatus;
} }
async function transitionPeerPushDebitTransaction( async function transitionPeerPushDebitTransaction(
@ -381,9 +381,9 @@ async function transitionPeerPushDebitTransaction(
pursePub, pursePub,
}); });
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPushPaymentInitiations]) .mktx((x) => [x.peerPushDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const ppiRec = await tx.peerPushPaymentInitiations.get(pursePub); const ppiRec = await tx.peerPushDebit.get(pursePub);
if (!ppiRec) { if (!ppiRec) {
return undefined; return undefined;
} }
@ -392,7 +392,7 @@ async function transitionPeerPushDebitTransaction(
} }
const oldTxState = computePeerPushDebitTransactionState(ppiRec); const oldTxState = computePeerPushDebitTransactionState(ppiRec);
ppiRec.status = transitionSpec.stTo; ppiRec.status = transitionSpec.stTo;
await tx.peerPushPaymentInitiations.put(ppiRec); await tx.peerPushDebit.put(ppiRec);
const newTxState = computePeerPushDebitTransactionState(ppiRec); const newTxState = computePeerPushDebitTransactionState(ppiRec);
return { return {
oldTxState, oldTxState,
@ -404,7 +404,7 @@ async function transitionPeerPushDebitTransaction(
async function processPeerPushDebitAbortingRefresh( async function processPeerPushDebitAbortingRefresh(
ws: InternalWalletState, ws: InternalWalletState,
peerPushInitiation: PeerPushPaymentInitiationRecord, peerPushInitiation: PeerPushDebitRecord,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const pursePub = peerPushInitiation.pursePub; const pursePub = peerPushInitiation.pursePub;
const abortRefreshGroupId = peerPushInitiation.abortRefreshGroupId; const abortRefreshGroupId = peerPushInitiation.abortRefreshGroupId;
@ -414,33 +414,33 @@ async function processPeerPushDebitAbortingRefresh(
pursePub: peerPushInitiation.pursePub, pursePub: peerPushInitiation.pursePub,
}); });
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.refreshGroups, x.peerPushPaymentInitiations]) .mktx((x) => [x.refreshGroups, x.peerPushDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const refreshGroup = await tx.refreshGroups.get(abortRefreshGroupId); const refreshGroup = await tx.refreshGroups.get(abortRefreshGroupId);
let newOpState: PeerPushPaymentInitiationStatus | undefined; let newOpState: PeerPushDebitStatus | undefined;
if (!refreshGroup) { if (!refreshGroup) {
// Maybe it got manually deleted? Means that we should // Maybe it got manually deleted? Means that we should
// just go into failed. // just go into failed.
logger.warn("no aborting refresh group found for deposit group"); logger.warn("no aborting refresh group found for deposit group");
newOpState = PeerPushPaymentInitiationStatus.Failed; newOpState = PeerPushDebitStatus.Failed;
} else { } else {
if (refreshGroup.operationStatus === RefreshOperationStatus.Finished) { if (refreshGroup.operationStatus === RefreshOperationStatus.Finished) {
newOpState = PeerPushPaymentInitiationStatus.Aborted; newOpState = PeerPushDebitStatus.Aborted;
} else if ( } else if (
refreshGroup.operationStatus === RefreshOperationStatus.Failed refreshGroup.operationStatus === RefreshOperationStatus.Failed
) { ) {
newOpState = PeerPushPaymentInitiationStatus.Failed; newOpState = PeerPushDebitStatus.Failed;
} }
} }
if (newOpState) { if (newOpState) {
const newDg = await tx.peerPushPaymentInitiations.get(pursePub); const newDg = await tx.peerPushDebit.get(pursePub);
if (!newDg) { if (!newDg) {
return; return;
} }
const oldTxState = computePeerPushDebitTransactionState(newDg); const oldTxState = computePeerPushDebitTransactionState(newDg);
newDg.status = newOpState; newDg.status = newOpState;
const newTxState = computePeerPushDebitTransactionState(newDg); const newTxState = computePeerPushDebitTransactionState(newDg);
await tx.peerPushPaymentInitiations.put(newDg); await tx.peerPushDebit.put(newDg);
return { oldTxState, newTxState }; return { oldTxState, newTxState };
} }
return undefined; return undefined;
@ -455,7 +455,7 @@ async function processPeerPushDebitAbortingRefresh(
*/ */
async function processPeerPushDebitReady( async function processPeerPushDebitReady(
ws: InternalWalletState, ws: InternalWalletState,
peerPushInitiation: PeerPushPaymentInitiationRecord, peerPushInitiation: PeerPushDebitRecord,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
logger.info("processing peer-push-debit pending(ready)"); logger.info("processing peer-push-debit pending(ready)");
const pursePub = peerPushInitiation.pursePub; const pursePub = peerPushInitiation.pursePub;
@ -488,8 +488,8 @@ async function processPeerPushDebitReady(
ws, ws,
peerPushInitiation.pursePub, peerPushInitiation.pursePub,
{ {
stFrom: PeerPushPaymentInitiationStatus.PendingReady, stFrom: PeerPushDebitStatus.PendingReady,
stTo: PeerPushPaymentInitiationStatus.Done, stTo: PeerPushDebitStatus.Done,
}, },
); );
return { return {
@ -501,8 +501,8 @@ async function processPeerPushDebitReady(
ws, ws,
peerPushInitiation.pursePub, peerPushInitiation.pursePub,
{ {
stFrom: PeerPushPaymentInitiationStatus.PendingReady, stFrom: PeerPushDebitStatus.PendingReady,
stTo: PeerPushPaymentInitiationStatus.Expired, stTo: PeerPushDebitStatus.Expired,
}, },
); );
return { return {
@ -528,9 +528,9 @@ export async function processPeerPushDebit(
pursePub: string, pursePub: string,
): Promise<TaskRunResult> { ): Promise<TaskRunResult> {
const peerPushInitiation = await ws.db const peerPushInitiation = await ws.db
.mktx((x) => [x.peerPushPaymentInitiations]) .mktx((x) => [x.peerPushDebit])
.runReadOnly(async (tx) => { .runReadOnly(async (tx) => {
return tx.peerPushPaymentInitiations.get(pursePub); return tx.peerPushDebit.get(pursePub);
}); });
if (!peerPushInitiation) { if (!peerPushInitiation) {
throw Error("peer push payment not found"); throw Error("peer push payment not found");
@ -550,13 +550,13 @@ export async function processPeerPushDebit(
} }
switch (peerPushInitiation.status) { switch (peerPushInitiation.status) {
case PeerPushPaymentInitiationStatus.PendingCreatePurse: case PeerPushDebitStatus.PendingCreatePurse:
return processPeerPushDebitCreateReserve(ws, peerPushInitiation); return processPeerPushDebitCreateReserve(ws, peerPushInitiation);
case PeerPushPaymentInitiationStatus.PendingReady: case PeerPushDebitStatus.PendingReady:
return processPeerPushDebitReady(ws, peerPushInitiation); return processPeerPushDebitReady(ws, peerPushInitiation);
case PeerPushPaymentInitiationStatus.AbortingDeletePurse: case PeerPushDebitStatus.AbortingDeletePurse:
return processPeerPushDebitAbortingDeletePurse(ws, peerPushInitiation); return processPeerPushDebitAbortingDeletePurse(ws, peerPushInitiation);
case PeerPushPaymentInitiationStatus.AbortingRefresh: case PeerPushDebitStatus.AbortingRefresh:
return processPeerPushDebitAbortingRefresh(ws, peerPushInitiation); return processPeerPushDebitAbortingRefresh(ws, peerPushInitiation);
default: { default: {
const txState = computePeerPushDebitTransactionState(peerPushInitiation); const txState = computePeerPushDebitTransactionState(peerPushInitiation);
@ -626,7 +626,7 @@ export async function initiatePeerPushDebit(
x.coinAvailability, x.coinAvailability,
x.denominations, x.denominations,
x.refreshGroups, x.refreshGroups,
x.peerPushPaymentInitiations, x.peerPushDebit,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
// FIXME: Instead of directly doing a spendCoin here, // FIXME: Instead of directly doing a spendCoin here,
@ -645,7 +645,7 @@ export async function initiatePeerPushDebit(
refreshReason: RefreshReason.PayPeerPush, refreshReason: RefreshReason.PayPeerPush,
}); });
const ppi: PeerPushPaymentInitiationRecord = { const ppi: PeerPushDebitRecord = {
amount: Amounts.stringify(instructedAmount), amount: Amounts.stringify(instructedAmount),
contractPriv: contractKeyPair.priv, contractPriv: contractKeyPair.priv,
contractPub: contractKeyPair.pub, contractPub: contractKeyPair.pub,
@ -657,7 +657,7 @@ export async function initiatePeerPushDebit(
pursePriv: pursePair.priv, pursePriv: pursePair.priv,
pursePub: pursePair.pub, pursePub: pursePair.pub,
timestampCreated: TalerPreciseTimestamp.now(), timestampCreated: TalerPreciseTimestamp.now(),
status: PeerPushPaymentInitiationStatus.PendingCreatePurse, status: PeerPushDebitStatus.PendingCreatePurse,
contractTerms: contractTerms, contractTerms: contractTerms,
contractEncNonce, contractEncNonce,
coinSel: { coinSel: {
@ -667,7 +667,7 @@ export async function initiatePeerPushDebit(
totalCost: Amounts.stringify(totalAmount), totalCost: Amounts.stringify(totalAmount),
}; };
await tx.peerPushPaymentInitiations.add(ppi); await tx.peerPushDebit.add(ppi);
await tx.contractTerms.put({ await tx.contractTerms.put({
h: hContractTerms, h: hContractTerms,
@ -701,32 +701,32 @@ export async function initiatePeerPushDebit(
} }
export function computePeerPushDebitTransactionActions( export function computePeerPushDebitTransactionActions(
ppiRecord: PeerPushPaymentInitiationRecord, ppiRecord: PeerPushDebitRecord,
): TransactionAction[] { ): TransactionAction[] {
switch (ppiRecord.status) { switch (ppiRecord.status) {
case PeerPushPaymentInitiationStatus.PendingCreatePurse: case PeerPushDebitStatus.PendingCreatePurse:
return [TransactionAction.Abort, TransactionAction.Suspend]; return [TransactionAction.Abort, TransactionAction.Suspend];
case PeerPushPaymentInitiationStatus.PendingReady: case PeerPushDebitStatus.PendingReady:
return [TransactionAction.Abort, TransactionAction.Suspend]; return [TransactionAction.Abort, TransactionAction.Suspend];
case PeerPushPaymentInitiationStatus.Aborted: case PeerPushDebitStatus.Aborted:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PeerPushPaymentInitiationStatus.AbortingDeletePurse: case PeerPushDebitStatus.AbortingDeletePurse:
return [TransactionAction.Suspend, TransactionAction.Fail]; return [TransactionAction.Suspend, TransactionAction.Fail];
case PeerPushPaymentInitiationStatus.AbortingRefresh: case PeerPushDebitStatus.AbortingRefresh:
return [TransactionAction.Suspend, TransactionAction.Fail]; return [TransactionAction.Suspend, TransactionAction.Fail];
case PeerPushPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPushDebitStatus.SuspendedAbortingDeletePurse:
return [TransactionAction.Resume, TransactionAction.Fail]; return [TransactionAction.Resume, TransactionAction.Fail];
case PeerPushPaymentInitiationStatus.SuspendedAbortingRefresh: case PeerPushDebitStatus.SuspendedAbortingRefresh:
return [TransactionAction.Resume, TransactionAction.Fail]; return [TransactionAction.Resume, TransactionAction.Fail];
case PeerPushPaymentInitiationStatus.SuspendedCreatePurse: case PeerPushDebitStatus.SuspendedCreatePurse:
return [TransactionAction.Resume, TransactionAction.Abort]; return [TransactionAction.Resume, TransactionAction.Abort];
case PeerPushPaymentInitiationStatus.SuspendedReady: case PeerPushDebitStatus.SuspendedReady:
return [TransactionAction.Suspend, TransactionAction.Abort]; return [TransactionAction.Suspend, TransactionAction.Abort];
case PeerPushPaymentInitiationStatus.Done: case PeerPushDebitStatus.Done:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PeerPushPaymentInitiationStatus.Expired: case PeerPushDebitStatus.Expired:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case PeerPushPaymentInitiationStatus.Failed: case PeerPushDebitStatus.Failed:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
} }
} }
@ -745,32 +745,32 @@ export async function abortPeerPushDebitTransaction(
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPushPaymentInitiations]) .mktx((x) => [x.peerPushDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pushDebitRec = await tx.peerPushPaymentInitiations.get(pursePub); const pushDebitRec = await tx.peerPushDebit.get(pursePub);
if (!pushDebitRec) { if (!pushDebitRec) {
logger.warn(`peer push debit ${pursePub} not found`); logger.warn(`peer push debit ${pursePub} not found`);
return; return;
} }
let newStatus: PeerPushPaymentInitiationStatus | undefined = undefined; let newStatus: PeerPushDebitStatus | undefined = undefined;
switch (pushDebitRec.status) { switch (pushDebitRec.status) {
case PeerPushPaymentInitiationStatus.PendingReady: case PeerPushDebitStatus.PendingReady:
case PeerPushPaymentInitiationStatus.SuspendedReady: case PeerPushDebitStatus.SuspendedReady:
newStatus = PeerPushPaymentInitiationStatus.AbortingDeletePurse; newStatus = PeerPushDebitStatus.AbortingDeletePurse;
break; break;
case PeerPushPaymentInitiationStatus.SuspendedCreatePurse: case PeerPushDebitStatus.SuspendedCreatePurse:
case PeerPushPaymentInitiationStatus.PendingCreatePurse: case PeerPushDebitStatus.PendingCreatePurse:
// Network request might already be in-flight! // Network request might already be in-flight!
newStatus = PeerPushPaymentInitiationStatus.AbortingDeletePurse; newStatus = PeerPushDebitStatus.AbortingDeletePurse;
break; break;
case PeerPushPaymentInitiationStatus.SuspendedAbortingRefresh: case PeerPushDebitStatus.SuspendedAbortingRefresh:
case PeerPushPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPushDebitStatus.SuspendedAbortingDeletePurse:
case PeerPushPaymentInitiationStatus.AbortingRefresh: case PeerPushDebitStatus.AbortingRefresh:
case PeerPushPaymentInitiationStatus.Done: case PeerPushDebitStatus.Done:
case PeerPushPaymentInitiationStatus.AbortingDeletePurse: case PeerPushDebitStatus.AbortingDeletePurse:
case PeerPushPaymentInitiationStatus.Aborted: case PeerPushDebitStatus.Aborted:
case PeerPushPaymentInitiationStatus.Expired: case PeerPushDebitStatus.Expired:
case PeerPushPaymentInitiationStatus.Failed: case PeerPushDebitStatus.Failed:
// Do nothing // Do nothing
break; break;
default: default:
@ -780,7 +780,7 @@ export async function abortPeerPushDebitTransaction(
const oldTxState = computePeerPushDebitTransactionState(pushDebitRec); const oldTxState = computePeerPushDebitTransactionState(pushDebitRec);
pushDebitRec.status = newStatus; pushDebitRec.status = newStatus;
const newTxState = computePeerPushDebitTransactionState(pushDebitRec); const newTxState = computePeerPushDebitTransactionState(pushDebitRec);
await tx.peerPushPaymentInitiations.put(pushDebitRec); await tx.peerPushDebit.put(pushDebitRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -805,32 +805,32 @@ export async function failPeerPushDebitTransaction(
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPushPaymentInitiations]) .mktx((x) => [x.peerPushDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pushDebitRec = await tx.peerPushPaymentInitiations.get(pursePub); const pushDebitRec = await tx.peerPushDebit.get(pursePub);
if (!pushDebitRec) { if (!pushDebitRec) {
logger.warn(`peer push debit ${pursePub} not found`); logger.warn(`peer push debit ${pursePub} not found`);
return; return;
} }
let newStatus: PeerPushPaymentInitiationStatus | undefined = undefined; let newStatus: PeerPushDebitStatus | undefined = undefined;
switch (pushDebitRec.status) { switch (pushDebitRec.status) {
case PeerPushPaymentInitiationStatus.AbortingRefresh: case PeerPushDebitStatus.AbortingRefresh:
case PeerPushPaymentInitiationStatus.SuspendedAbortingRefresh: case PeerPushDebitStatus.SuspendedAbortingRefresh:
// FIXME: What to do about the refresh group? // FIXME: What to do about the refresh group?
newStatus = PeerPushPaymentInitiationStatus.Failed; newStatus = PeerPushDebitStatus.Failed;
break; break;
case PeerPushPaymentInitiationStatus.AbortingDeletePurse: case PeerPushDebitStatus.AbortingDeletePurse:
case PeerPushPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPushDebitStatus.SuspendedAbortingDeletePurse:
case PeerPushPaymentInitiationStatus.PendingReady: case PeerPushDebitStatus.PendingReady:
case PeerPushPaymentInitiationStatus.SuspendedReady: case PeerPushDebitStatus.SuspendedReady:
case PeerPushPaymentInitiationStatus.SuspendedCreatePurse: case PeerPushDebitStatus.SuspendedCreatePurse:
case PeerPushPaymentInitiationStatus.PendingCreatePurse: case PeerPushDebitStatus.PendingCreatePurse:
newStatus = PeerPushPaymentInitiationStatus.Failed; newStatus = PeerPushDebitStatus.Failed;
break; break;
case PeerPushPaymentInitiationStatus.Done: case PeerPushDebitStatus.Done:
case PeerPushPaymentInitiationStatus.Aborted: case PeerPushDebitStatus.Aborted:
case PeerPushPaymentInitiationStatus.Failed: case PeerPushDebitStatus.Failed:
case PeerPushPaymentInitiationStatus.Expired: case PeerPushDebitStatus.Expired:
// Do nothing // Do nothing
break; break;
default: default:
@ -840,7 +840,7 @@ export async function failPeerPushDebitTransaction(
const oldTxState = computePeerPushDebitTransactionState(pushDebitRec); const oldTxState = computePeerPushDebitTransactionState(pushDebitRec);
pushDebitRec.status = newStatus; pushDebitRec.status = newStatus;
const newTxState = computePeerPushDebitTransactionState(pushDebitRec); const newTxState = computePeerPushDebitTransactionState(pushDebitRec);
await tx.peerPushPaymentInitiations.put(pushDebitRec); await tx.peerPushDebit.put(pushDebitRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -865,36 +865,36 @@ export async function suspendPeerPushDebitTransaction(
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPushPaymentInitiations]) .mktx((x) => [x.peerPushDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pushDebitRec = await tx.peerPushPaymentInitiations.get(pursePub); const pushDebitRec = await tx.peerPushDebit.get(pursePub);
if (!pushDebitRec) { if (!pushDebitRec) {
logger.warn(`peer push debit ${pursePub} not found`); logger.warn(`peer push debit ${pursePub} not found`);
return; return;
} }
let newStatus: PeerPushPaymentInitiationStatus | undefined = undefined; let newStatus: PeerPushDebitStatus | undefined = undefined;
switch (pushDebitRec.status) { switch (pushDebitRec.status) {
case PeerPushPaymentInitiationStatus.PendingCreatePurse: case PeerPushDebitStatus.PendingCreatePurse:
newStatus = PeerPushPaymentInitiationStatus.SuspendedCreatePurse; newStatus = PeerPushDebitStatus.SuspendedCreatePurse;
break; break;
case PeerPushPaymentInitiationStatus.AbortingRefresh: case PeerPushDebitStatus.AbortingRefresh:
newStatus = PeerPushPaymentInitiationStatus.SuspendedAbortingRefresh; newStatus = PeerPushDebitStatus.SuspendedAbortingRefresh;
break; break;
case PeerPushPaymentInitiationStatus.AbortingDeletePurse: case PeerPushDebitStatus.AbortingDeletePurse:
newStatus = newStatus =
PeerPushPaymentInitiationStatus.SuspendedAbortingDeletePurse; PeerPushDebitStatus.SuspendedAbortingDeletePurse;
break; break;
case PeerPushPaymentInitiationStatus.PendingReady: case PeerPushDebitStatus.PendingReady:
newStatus = PeerPushPaymentInitiationStatus.SuspendedReady; newStatus = PeerPushDebitStatus.SuspendedReady;
break; break;
case PeerPushPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPushDebitStatus.SuspendedAbortingDeletePurse:
case PeerPushPaymentInitiationStatus.SuspendedAbortingRefresh: case PeerPushDebitStatus.SuspendedAbortingRefresh:
case PeerPushPaymentInitiationStatus.SuspendedReady: case PeerPushDebitStatus.SuspendedReady:
case PeerPushPaymentInitiationStatus.SuspendedCreatePurse: case PeerPushDebitStatus.SuspendedCreatePurse:
case PeerPushPaymentInitiationStatus.Done: case PeerPushDebitStatus.Done:
case PeerPushPaymentInitiationStatus.Aborted: case PeerPushDebitStatus.Aborted:
case PeerPushPaymentInitiationStatus.Failed: case PeerPushDebitStatus.Failed:
case PeerPushPaymentInitiationStatus.Expired: case PeerPushDebitStatus.Expired:
// Do nothing // Do nothing
break; break;
default: default:
@ -904,7 +904,7 @@ export async function suspendPeerPushDebitTransaction(
const oldTxState = computePeerPushDebitTransactionState(pushDebitRec); const oldTxState = computePeerPushDebitTransactionState(pushDebitRec);
pushDebitRec.status = newStatus; pushDebitRec.status = newStatus;
const newTxState = computePeerPushDebitTransactionState(pushDebitRec); const newTxState = computePeerPushDebitTransactionState(pushDebitRec);
await tx.peerPushPaymentInitiations.put(pushDebitRec); await tx.peerPushDebit.put(pushDebitRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -929,35 +929,35 @@ export async function resumePeerPushDebitTransaction(
}); });
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
const transitionInfo = await ws.db const transitionInfo = await ws.db
.mktx((x) => [x.peerPushPaymentInitiations]) .mktx((x) => [x.peerPushDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pushDebitRec = await tx.peerPushPaymentInitiations.get(pursePub); const pushDebitRec = await tx.peerPushDebit.get(pursePub);
if (!pushDebitRec) { if (!pushDebitRec) {
logger.warn(`peer push debit ${pursePub} not found`); logger.warn(`peer push debit ${pursePub} not found`);
return; return;
} }
let newStatus: PeerPushPaymentInitiationStatus | undefined = undefined; let newStatus: PeerPushDebitStatus | undefined = undefined;
switch (pushDebitRec.status) { switch (pushDebitRec.status) {
case PeerPushPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPushDebitStatus.SuspendedAbortingDeletePurse:
newStatus = PeerPushPaymentInitiationStatus.AbortingDeletePurse; newStatus = PeerPushDebitStatus.AbortingDeletePurse;
break; break;
case PeerPushPaymentInitiationStatus.SuspendedAbortingRefresh: case PeerPushDebitStatus.SuspendedAbortingRefresh:
newStatus = PeerPushPaymentInitiationStatus.AbortingRefresh; newStatus = PeerPushDebitStatus.AbortingRefresh;
break; break;
case PeerPushPaymentInitiationStatus.SuspendedReady: case PeerPushDebitStatus.SuspendedReady:
newStatus = PeerPushPaymentInitiationStatus.PendingReady; newStatus = PeerPushDebitStatus.PendingReady;
break; break;
case PeerPushPaymentInitiationStatus.SuspendedCreatePurse: case PeerPushDebitStatus.SuspendedCreatePurse:
newStatus = PeerPushPaymentInitiationStatus.PendingCreatePurse; newStatus = PeerPushDebitStatus.PendingCreatePurse;
break; break;
case PeerPushPaymentInitiationStatus.PendingCreatePurse: case PeerPushDebitStatus.PendingCreatePurse:
case PeerPushPaymentInitiationStatus.AbortingRefresh: case PeerPushDebitStatus.AbortingRefresh:
case PeerPushPaymentInitiationStatus.AbortingDeletePurse: case PeerPushDebitStatus.AbortingDeletePurse:
case PeerPushPaymentInitiationStatus.PendingReady: case PeerPushDebitStatus.PendingReady:
case PeerPushPaymentInitiationStatus.Done: case PeerPushDebitStatus.Done:
case PeerPushPaymentInitiationStatus.Aborted: case PeerPushDebitStatus.Aborted:
case PeerPushPaymentInitiationStatus.Failed: case PeerPushDebitStatus.Failed:
case PeerPushPaymentInitiationStatus.Expired: case PeerPushDebitStatus.Expired:
// Do nothing // Do nothing
break; break;
default: default:
@ -967,7 +967,7 @@ export async function resumePeerPushDebitTransaction(
const oldTxState = computePeerPushDebitTransactionState(pushDebitRec); const oldTxState = computePeerPushDebitTransactionState(pushDebitRec);
pushDebitRec.status = newStatus; pushDebitRec.status = newStatus;
const newTxState = computePeerPushDebitTransactionState(pushDebitRec); const newTxState = computePeerPushDebitTransactionState(pushDebitRec);
await tx.peerPushPaymentInitiations.put(pushDebitRec); await tx.peerPushDebit.put(pushDebitRec);
return { return {
oldTxState, oldTxState,
newTxState, newTxState,
@ -980,62 +980,62 @@ export async function resumePeerPushDebitTransaction(
} }
export function computePeerPushDebitTransactionState( export function computePeerPushDebitTransactionState(
ppiRecord: PeerPushPaymentInitiationRecord, ppiRecord: PeerPushDebitRecord,
): TransactionState { ): TransactionState {
switch (ppiRecord.status) { switch (ppiRecord.status) {
case PeerPushPaymentInitiationStatus.PendingCreatePurse: case PeerPushDebitStatus.PendingCreatePurse:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.CreatePurse, minor: TransactionMinorState.CreatePurse,
}; };
case PeerPushPaymentInitiationStatus.PendingReady: case PeerPushDebitStatus.PendingReady:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.Ready, minor: TransactionMinorState.Ready,
}; };
case PeerPushPaymentInitiationStatus.Aborted: case PeerPushDebitStatus.Aborted:
return { return {
major: TransactionMajorState.Aborted, major: TransactionMajorState.Aborted,
}; };
case PeerPushPaymentInitiationStatus.AbortingDeletePurse: case PeerPushDebitStatus.AbortingDeletePurse:
return { return {
major: TransactionMajorState.Aborting, major: TransactionMajorState.Aborting,
minor: TransactionMinorState.DeletePurse, minor: TransactionMinorState.DeletePurse,
}; };
case PeerPushPaymentInitiationStatus.AbortingRefresh: case PeerPushDebitStatus.AbortingRefresh:
return { return {
major: TransactionMajorState.Aborting, major: TransactionMajorState.Aborting,
minor: TransactionMinorState.Refresh, minor: TransactionMinorState.Refresh,
}; };
case PeerPushPaymentInitiationStatus.SuspendedAbortingDeletePurse: case PeerPushDebitStatus.SuspendedAbortingDeletePurse:
return { return {
major: TransactionMajorState.SuspendedAborting, major: TransactionMajorState.SuspendedAborting,
minor: TransactionMinorState.DeletePurse, minor: TransactionMinorState.DeletePurse,
}; };
case PeerPushPaymentInitiationStatus.SuspendedAbortingRefresh: case PeerPushDebitStatus.SuspendedAbortingRefresh:
return { return {
major: TransactionMajorState.SuspendedAborting, major: TransactionMajorState.SuspendedAborting,
minor: TransactionMinorState.Refresh, minor: TransactionMinorState.Refresh,
}; };
case PeerPushPaymentInitiationStatus.SuspendedCreatePurse: case PeerPushDebitStatus.SuspendedCreatePurse:
return { return {
major: TransactionMajorState.Suspended, major: TransactionMajorState.Suspended,
minor: TransactionMinorState.CreatePurse, minor: TransactionMinorState.CreatePurse,
}; };
case PeerPushPaymentInitiationStatus.SuspendedReady: case PeerPushDebitStatus.SuspendedReady:
return { return {
major: TransactionMajorState.Suspended, major: TransactionMajorState.Suspended,
minor: TransactionMinorState.Ready, minor: TransactionMinorState.Ready,
}; };
case PeerPushPaymentInitiationStatus.Done: case PeerPushDebitStatus.Done:
return { return {
major: TransactionMajorState.Done, major: TransactionMajorState.Done,
}; };
case PeerPushPaymentInitiationStatus.Failed: case PeerPushDebitStatus.Failed:
return { return {
major: TransactionMajorState.Failed, major: TransactionMajorState.Failed,
}; };
case PeerPushPaymentInitiationStatus.Expired: case PeerPushDebitStatus.Expired:
return { return {
major: TransactionMajorState.Expired, major: TransactionMajorState.Expired,
}; };

80
packages/taler-wallet-core/src/operations/pending.ts
View File

@ -26,11 +26,10 @@ import {
WalletStoresV1, WalletStoresV1,
BackupProviderStateTag, BackupProviderStateTag,
RefreshCoinStatus, RefreshCoinStatus,
OperationStatusRange, PeerPushDebitStatus,
PeerPushPaymentInitiationStatus,
PeerPullDebitRecordStatus, PeerPullDebitRecordStatus,
PeerPushPaymentIncomingStatus, PeerPushCreditStatus,
PeerPullPaymentInitiationStatus, PeerPullPaymentCreditStatus,
WithdrawalGroupStatus, WithdrawalGroupStatus,
RewardRecordStatus, RewardRecordStatus,
DepositOperationStatus, DepositOperationStatus,
@ -39,13 +38,14 @@ import {
DepositGroupRecord, DepositGroupRecord,
RewardRecord, RewardRecord,
PurchaseRecord, PurchaseRecord,
PeerPullPaymentInitiationRecord, PeerPullCreditRecord,
PeerPullPaymentIncomingRecord, PeerPullPaymentIncomingRecord,
PeerPushPaymentInitiationRecord, PeerPushDebitRecord,
PeerPushPaymentIncomingRecord, PeerPushPaymentIncomingRecord,
RefundGroupRecord, RefundGroupRecord,
RefundGroupStatus, RefundGroupStatus,
ExchangeEntryDbUpdateStatus, ExchangeEntryDbUpdateStatus,
RefreshOperationStatus,
} from "../db.js"; } from "../db.js";
import { import {
PendingOperationsResponse, PendingOperationsResponse,
@ -136,8 +136,8 @@ export async function iterRecordsForRefresh(
let refreshGroups: RefreshGroupRecord[]; let refreshGroups: RefreshGroupRecord[];
if (filter.onlyState === "nonfinal") { if (filter.onlyState === "nonfinal") {
const keyRange = GlobalIDB.KeyRange.bound( const keyRange = GlobalIDB.KeyRange.bound(
OperationStatusRange.ACTIVE_START, RefreshOperationStatus.Pending,
OperationStatusRange.ACTIVE_END, RefreshOperationStatus.Suspended,
); );
refreshGroups = await tx.refreshGroups.indexes.byStatus.getAll(keyRange); refreshGroups = await tx.refreshGroups.indexes.byStatus.getAll(keyRange);
} else { } else {
@ -470,28 +470,28 @@ async function gatherBackupPending(
export async function iterRecordsForPeerPullInitiation( export async function iterRecordsForPeerPullInitiation(
tx: GetReadOnlyAccess<{ tx: GetReadOnlyAccess<{
peerPullPaymentInitiations: typeof WalletStoresV1.peerPullPaymentInitiations; peerPullCredit: typeof WalletStoresV1.peerPullCredit;
}>, }>,
filter: TransactionRecordFilter, filter: TransactionRecordFilter,
f: (r: PeerPullPaymentInitiationRecord) => Promise<void>, f: (r: PeerPullCreditRecord) => Promise<void>,
): Promise<void> { ): Promise<void> {
if (filter.onlyState === "nonfinal") { if (filter.onlyState === "nonfinal") {
const keyRange = GlobalIDB.KeyRange.bound( const keyRange = GlobalIDB.KeyRange.bound(
PeerPullPaymentInitiationStatus.PendingCreatePurse, PeerPullPaymentCreditStatus.PendingCreatePurse,
PeerPullPaymentInitiationStatus.AbortingDeletePurse, PeerPullPaymentCreditStatus.AbortingDeletePurse,
); );
await tx.peerPullPaymentInitiations.indexes.byStatus await tx.peerPullCredit.indexes.byStatus
.iter(keyRange) .iter(keyRange)
.forEachAsync(f); .forEachAsync(f);
} else { } else {
await tx.peerPullPaymentInitiations.indexes.byStatus.iter().forEachAsync(f); await tx.peerPullCredit.indexes.byStatus.iter().forEachAsync(f);
} }
} }
async function gatherPeerPullInitiationPending( async function gatherPeerPullInitiationPending(
ws: InternalWalletState, ws: InternalWalletState,
tx: GetReadOnlyAccess<{ tx: GetReadOnlyAccess<{
peerPullPaymentInitiations: typeof WalletStoresV1.peerPullPaymentInitiations; peerPullCredit: typeof WalletStoresV1.peerPullCredit;
operationRetries: typeof WalletStoresV1.operationRetries; operationRetries: typeof WalletStoresV1.operationRetries;
}>, }>,
now: AbsoluteTime, now: AbsoluteTime,
@ -518,7 +518,7 @@ async function gatherPeerPullInitiationPending(
export async function iterRecordsForPeerPullDebit( export async function iterRecordsForPeerPullDebit(
tx: GetReadOnlyAccess<{ tx: GetReadOnlyAccess<{
peerPullPaymentIncoming: typeof WalletStoresV1.peerPullPaymentIncoming; peerPullDebit: typeof WalletStoresV1.peerPullDebit;
}>, }>,
filter: TransactionRecordFilter, filter: TransactionRecordFilter,
f: (r: PeerPullPaymentIncomingRecord) => Promise<void>, f: (r: PeerPullPaymentIncomingRecord) => Promise<void>,
@ -528,18 +528,18 @@ export async function iterRecordsForPeerPullDebit(
PeerPullDebitRecordStatus.PendingDeposit, PeerPullDebitRecordStatus.PendingDeposit,
PeerPullDebitRecordStatus.AbortingRefresh, PeerPullDebitRecordStatus.AbortingRefresh,
); );
await tx.peerPullPaymentIncoming.indexes.byStatus await tx.peerPullDebit.indexes.byStatus
.iter(keyRange) .iter(keyRange)
.forEachAsync(f); .forEachAsync(f);
} else { } else {
await tx.peerPullPaymentIncoming.indexes.byStatus.iter().forEachAsync(f); await tx.peerPullDebit.indexes.byStatus.iter().forEachAsync(f);
} }
} }
async function gatherPeerPullDebitPending( async function gatherPeerPullDebitPending(
ws: InternalWalletState, ws: InternalWalletState,
tx: GetReadOnlyAccess<{ tx: GetReadOnlyAccess<{
peerPullPaymentIncoming: typeof WalletStoresV1.peerPullPaymentIncoming; peerPullDebit: typeof WalletStoresV1.peerPullDebit;
operationRetries: typeof WalletStoresV1.operationRetries; operationRetries: typeof WalletStoresV1.operationRetries;
}>, }>,
now: AbsoluteTime, now: AbsoluteTime,
@ -558,7 +558,7 @@ async function gatherPeerPullDebitPending(
...getPendingCommon(ws, opId, timestampDue), ...getPendingCommon(ws, opId, timestampDue),
givesLifeness: true, givesLifeness: true,
retryInfo: retryRecord?.retryInfo, retryInfo: retryRecord?.retryInfo,
peerPullPaymentIncomingId: pi.peerPullPaymentIncomingId, peerPullDebitId: pi.peerPullDebitId,
}); });
}, },
); );
@ -566,28 +566,28 @@ async function gatherPeerPullDebitPending(
export async function iterRecordsForPeerPushInitiation( export async function iterRecordsForPeerPushInitiation(
tx: GetReadOnlyAccess<{ tx: GetReadOnlyAccess<{
peerPushPaymentInitiations: typeof WalletStoresV1.peerPushPaymentInitiations; peerPushDebit: typeof WalletStoresV1.peerPushDebit;
}>, }>,
filter: TransactionRecordFilter, filter: TransactionRecordFilter,
f: (r: PeerPushPaymentInitiationRecord) => Promise<void>, f: (r: PeerPushDebitRecord) => Promise<void>,
): Promise<void> { ): Promise<void> {
if (filter.onlyState === "nonfinal") { if (filter.onlyState === "nonfinal") {
const keyRange = GlobalIDB.KeyRange.bound( const keyRange = GlobalIDB.KeyRange.bound(
PeerPushPaymentInitiationStatus.PendingCreatePurse, PeerPushDebitStatus.PendingCreatePurse,
PeerPushPaymentInitiationStatus.AbortingRefresh, PeerPushDebitStatus.AbortingRefresh,
); );
await tx.peerPushPaymentInitiations.indexes.byStatus await tx.peerPushDebit.indexes.byStatus
.iter(keyRange) .iter(keyRange)
.forEachAsync(f); .forEachAsync(f);
} else { } else {
await tx.peerPushPaymentInitiations.indexes.byStatus.iter().forEachAsync(f); await tx.peerPushDebit.indexes.byStatus.iter().forEachAsync(f);
} }
} }
async function gatherPeerPushInitiationPending( async function gatherPeerPushInitiationPending(
ws: InternalWalletState, ws: InternalWalletState,
tx: GetReadOnlyAccess<{ tx: GetReadOnlyAccess<{
peerPushPaymentInitiations: typeof WalletStoresV1.peerPushPaymentInitiations; peerPushDebit: typeof WalletStoresV1.peerPushDebit;
operationRetries: typeof WalletStoresV1.operationRetries; operationRetries: typeof WalletStoresV1.operationRetries;
}>, }>,
now: AbsoluteTime, now: AbsoluteTime,
@ -614,36 +614,36 @@ async function gatherPeerPushInitiationPending(
export async function iterRecordsForPeerPushCredit( export async function iterRecordsForPeerPushCredit(
tx: GetReadOnlyAccess<{ tx: GetReadOnlyAccess<{
peerPushPaymentIncoming: typeof WalletStoresV1.peerPushPaymentIncoming; peerPushCredit: typeof WalletStoresV1.peerPushCredit;
}>, }>,
filter: TransactionRecordFilter, filter: TransactionRecordFilter,
f: (r: PeerPushPaymentIncomingRecord) => Promise<void>, f: (r: PeerPushPaymentIncomingRecord) => Promise<void>,
): Promise<void> { ): Promise<void> {
if (filter.onlyState === "nonfinal") { if (filter.onlyState === "nonfinal") {
const keyRange = GlobalIDB.KeyRange.bound( const keyRange = GlobalIDB.KeyRange.bound(
PeerPushPaymentIncomingStatus.PendingMerge, PeerPushCreditStatus.PendingMerge,
PeerPushPaymentIncomingStatus.PendingWithdrawing, PeerPushCreditStatus.PendingWithdrawing,
); );
await tx.peerPushPaymentIncoming.indexes.byStatus await tx.peerPushCredit.indexes.byStatus
.iter(keyRange) .iter(keyRange)
.forEachAsync(f); .forEachAsync(f);
} else { } else {
await tx.peerPushPaymentIncoming.indexes.byStatus.iter().forEachAsync(f); await tx.peerPushCredit.indexes.byStatus.iter().forEachAsync(f);
} }
} }
async function gatherPeerPushCreditPending( async function gatherPeerPushCreditPending(
ws: InternalWalletState, ws: InternalWalletState,
tx: GetReadOnlyAccess<{ tx: GetReadOnlyAccess<{
peerPushPaymentIncoming: typeof WalletStoresV1.peerPushPaymentIncoming; peerPushCredit: typeof WalletStoresV1.peerPushCredit;
operationRetries: typeof WalletStoresV1.operationRetries; operationRetries: typeof WalletStoresV1.operationRetries;
}>, }>,
now: AbsoluteTime, now: AbsoluteTime,
resp: PendingOperationsResponse, resp: PendingOperationsResponse,
): Promise<void> { ): Promise<void> {
const keyRange = GlobalIDB.KeyRange.bound( const keyRange = GlobalIDB.KeyRange.bound(
PeerPushPaymentIncomingStatus.PendingMerge, PeerPushCreditStatus.PendingMerge,
PeerPushPaymentIncomingStatus.PendingWithdrawing, PeerPushCreditStatus.PendingWithdrawing,
); );
await iterRecordsForPeerPushCredit( await iterRecordsForPeerPushCredit(
tx, tx,
@ -658,7 +658,7 @@ async function gatherPeerPushCreditPending(
...getPendingCommon(ws, opId, timestampDue), ...getPendingCommon(ws, opId, timestampDue),
givesLifeness: true, givesLifeness: true,
retryInfo: retryRecord?.retryInfo, retryInfo: retryRecord?.retryInfo,
peerPushPaymentIncomingId: pi.peerPushPaymentIncomingId, peerPushCreditId: pi.peerPushCreditId,
}); });
}, },
); );
@ -682,10 +682,10 @@ export async function getPendingOperations(
x.depositGroups, x.depositGroups,
x.recoupGroups, x.recoupGroups,
x.operationRetries, x.operationRetries,
x.peerPullPaymentInitiations, x.peerPullCredit,
x.peerPushPaymentInitiations, x.peerPushDebit,
x.peerPullPaymentIncoming, x.peerPullDebit,
x.peerPushPaymentIncoming, x.peerPushCredit,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const resp: PendingOperationsResponse = { const resp: PendingOperationsResponse = {

14
packages/taler-wallet-core/src/operations/reward.ts
View File

@ -108,7 +108,7 @@ export function computeRewardTransactionStatus(
major: TransactionMajorState.Dialog, major: TransactionMajorState.Dialog,
minor: TransactionMinorState.Proposed, minor: TransactionMinorState.Proposed,
}; };
case RewardRecordStatus.SuspendidPickup: case RewardRecordStatus.SuspendedPickup:
return { return {
major: TransactionMajorState.Pending, major: TransactionMajorState.Pending,
minor: TransactionMinorState.Pickup, minor: TransactionMinorState.Pickup,
@ -128,7 +128,7 @@ export function computeTipTransactionActions(
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case RewardRecordStatus.PendingPickup: case RewardRecordStatus.PendingPickup:
return [TransactionAction.Suspend, TransactionAction.Fail]; return [TransactionAction.Suspend, TransactionAction.Fail];
case RewardRecordStatus.SuspendidPickup: case RewardRecordStatus.SuspendedPickup:
return [TransactionAction.Resume, TransactionAction.Fail]; return [TransactionAction.Resume, TransactionAction.Fail];
case RewardRecordStatus.DialogAccept: case RewardRecordStatus.DialogAccept:
return [TransactionAction.Abort]; return [TransactionAction.Abort];
@ -255,7 +255,7 @@ export async function processTip(
case RewardRecordStatus.Aborted: case RewardRecordStatus.Aborted:
case RewardRecordStatus.DialogAccept: case RewardRecordStatus.DialogAccept:
case RewardRecordStatus.Done: case RewardRecordStatus.Done:
case RewardRecordStatus.SuspendidPickup: case RewardRecordStatus.SuspendedPickup:
return TaskRunResult.finished(); return TaskRunResult.finished();
} }
@ -496,12 +496,12 @@ export async function suspendRewardTransaction(
let newStatus: RewardRecordStatus | undefined = undefined; let newStatus: RewardRecordStatus | undefined = undefined;
switch (tipRec.status) { switch (tipRec.status) {
case RewardRecordStatus.Done: case RewardRecordStatus.Done:
case RewardRecordStatus.SuspendidPickup: case RewardRecordStatus.SuspendedPickup:
case RewardRecordStatus.Aborted: case RewardRecordStatus.Aborted:
case RewardRecordStatus.DialogAccept: case RewardRecordStatus.DialogAccept:
break; break;
case RewardRecordStatus.PendingPickup: case RewardRecordStatus.PendingPickup:
newStatus = RewardRecordStatus.SuspendidPickup; newStatus = RewardRecordStatus.SuspendedPickup;
break; break;
default: default:
@ -551,7 +551,7 @@ export async function resumeTipTransaction(
case RewardRecordStatus.Aborted: case RewardRecordStatus.Aborted:
case RewardRecordStatus.DialogAccept: case RewardRecordStatus.DialogAccept:
break; break;
case RewardRecordStatus.SuspendidPickup: case RewardRecordStatus.SuspendedPickup:
newStatus = RewardRecordStatus.PendingPickup; newStatus = RewardRecordStatus.PendingPickup;
break; break;
default: default:
@ -608,7 +608,7 @@ export async function abortTipTransaction(
case RewardRecordStatus.PendingPickup: case RewardRecordStatus.PendingPickup:
case RewardRecordStatus.DialogAccept: case RewardRecordStatus.DialogAccept:
break; break;
case RewardRecordStatus.SuspendidPickup: case RewardRecordStatus.SuspendedPickup:
newStatus = RewardRecordStatus.Aborted; newStatus = RewardRecordStatus.Aborted;
break; break;
default: default:

4
packages/taler-wallet-core/src/operations/testing.ts
View File

@ -700,7 +700,7 @@ export async function runIntegrationTest2(
}); });
await confirmPeerPushCredit(ws, { await confirmPeerPushCredit(ws, {
peerPushPaymentIncomingId: peerPushCredit.peerPushPaymentIncomingId, peerPushCreditId: peerPushCredit.peerPushCreditId,
}); });
const peerPullInit = await initiatePeerPullPayment(ws, { const peerPullInit = await initiatePeerPullPayment(ws, {
@ -723,7 +723,7 @@ export async function runIntegrationTest2(
}); });
await confirmPeerPullDebit(ws, { await confirmPeerPullDebit(ws, {
peerPullPaymentIncomingId: peerPullInc.peerPullPaymentIncomingId, peerPullDebitId: peerPullInc.peerPullDebitId,
}); });
await waitUntilDone(ws); await waitUntilDone(ws);

122
packages/taler-wallet-core/src/operations/transactions.ts
View File

@ -50,10 +50,10 @@ import {
OperationRetryRecord, OperationRetryRecord,
PeerPullPaymentIncomingRecord, PeerPullPaymentIncomingRecord,
PeerPullDebitRecordStatus, PeerPullDebitRecordStatus,
PeerPullPaymentInitiationRecord, PeerPullCreditRecord,
PeerPushPaymentIncomingRecord, PeerPushPaymentIncomingRecord,
PeerPushPaymentIncomingStatus, PeerPushCreditStatus,
PeerPushPaymentInitiationRecord, PeerPushDebitRecord,
PurchaseRecord, PurchaseRecord,
PurchaseStatus, PurchaseStatus,
RefreshGroupRecord, RefreshGroupRecord,
@ -335,10 +335,10 @@ export async function getTransactionById(
} }
case TransactionType.PeerPullDebit: { case TransactionType.PeerPullDebit: {
return await ws.db return await ws.db
.mktx((x) => [x.peerPullPaymentIncoming]) .mktx((x) => [x.peerPullDebit])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const debit = await tx.peerPullPaymentIncoming.get( const debit = await tx.peerPullDebit.get(
parsedTx.peerPullPaymentIncomingId, parsedTx.peerPullDebitId,
); );
if (!debit) throw Error("not found"); if (!debit) throw Error("not found");
return buildTransactionForPullPaymentDebit(debit); return buildTransactionForPullPaymentDebit(debit);
@ -347,9 +347,9 @@ export async function getTransactionById(
case TransactionType.PeerPushDebit: { case TransactionType.PeerPushDebit: {
return await ws.db return await ws.db
.mktx((x) => [x.peerPushPaymentInitiations, x.contractTerms]) .mktx((x) => [x.peerPushDebit, x.contractTerms])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const debit = await tx.peerPushPaymentInitiations.get( const debit = await tx.peerPushDebit.get(
parsedTx.pursePub, parsedTx.pursePub,
); );
if (!debit) throw Error("not found"); if (!debit) throw Error("not found");
@ -363,17 +363,17 @@ export async function getTransactionById(
} }
case TransactionType.PeerPushCredit: { case TransactionType.PeerPushCredit: {
const peerPushPaymentIncomingId = parsedTx.peerPushPaymentIncomingId; const peerPushCreditId = parsedTx.peerPushCreditId;
return await ws.db return await ws.db
.mktx((x) => [ .mktx((x) => [
x.peerPushPaymentIncoming, x.peerPushCredit,
x.contractTerms, x.contractTerms,
x.withdrawalGroups, x.withdrawalGroups,
x.operationRetries, x.operationRetries,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pushInc = await tx.peerPushPaymentIncoming.get( const pushInc = await tx.peerPushCredit.get(
peerPushPaymentIncomingId, peerPushCreditId,
); );
if (!pushInc) throw Error("not found"); if (!pushInc) throw Error("not found");
const ct = await tx.contractTerms.get(pushInc.contractTermsHash); const ct = await tx.contractTerms.get(pushInc.contractTermsHash);
@ -405,13 +405,13 @@ export async function getTransactionById(
const pursePub = parsedTx.pursePub; const pursePub = parsedTx.pursePub;
return await ws.db return await ws.db
.mktx((x) => [ .mktx((x) => [
x.peerPullPaymentInitiations, x.peerPullCredit,
x.contractTerms, x.contractTerms,
x.withdrawalGroups, x.withdrawalGroups,
x.operationRetries, x.operationRetries,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pushInc = await tx.peerPullPaymentInitiations.get(pursePub); const pushInc = await tx.peerPullCredit.get(pursePub);
if (!pushInc) throw Error("not found"); if (!pushInc) throw Error("not found");
const ct = await tx.contractTerms.get(pushInc.contractTermsHash); const ct = await tx.contractTerms.get(pushInc.contractTermsHash);
checkDbInvariant(!!ct); checkDbInvariant(!!ct);
@ -442,7 +442,7 @@ export async function getTransactionById(
} }
function buildTransactionForPushPaymentDebit( function buildTransactionForPushPaymentDebit(
pi: PeerPushPaymentInitiationRecord, pi: PeerPushDebitRecord,
contractTerms: PeerContractTerms, contractTerms: PeerContractTerms,
ort?: OperationRetryRecord, ort?: OperationRetryRecord,
): Transaction { ): Transaction {
@ -490,14 +490,14 @@ function buildTransactionForPullPaymentDebit(
timestamp: pi.timestampCreated, timestamp: pi.timestampCreated,
transactionId: constructTransactionIdentifier({ transactionId: constructTransactionIdentifier({
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId: pi.peerPullPaymentIncomingId, peerPullDebitId: pi.peerPullDebitId,
}), }),
...(ort?.lastError ? { error: ort.lastError } : {}), ...(ort?.lastError ? { error: ort.lastError } : {}),
}; };
} }
function buildTransactionForPeerPullCredit( function buildTransactionForPeerPullCredit(
pullCredit: PeerPullPaymentInitiationRecord, pullCredit: PeerPullCreditRecord,
pullCreditOrt: OperationRetryRecord | undefined, pullCreditOrt: OperationRetryRecord | undefined,
peerContractTerms: PeerContractTerms, peerContractTerms: PeerContractTerms,
wsr: WithdrawalGroupRecord | undefined, wsr: WithdrawalGroupRecord | undefined,
@ -606,7 +606,7 @@ function buildTransactionForPeerPushCredit(
timestamp: wsr.timestampStart, timestamp: wsr.timestampStart,
transactionId: constructTransactionIdentifier({ transactionId: constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId: pushInc.peerPushPaymentIncomingId, peerPushCreditId: pushInc.peerPushCreditId,
}), }),
kycUrl: pushInc.kycUrl, kycUrl: pushInc.kycUrl,
...(wsrOrt?.lastError ? { error: wsrOrt.lastError } : {}), ...(wsrOrt?.lastError ? { error: wsrOrt.lastError } : {}),
@ -629,7 +629,7 @@ function buildTransactionForPeerPushCredit(
timestamp: pushInc.timestamp, timestamp: pushInc.timestamp,
transactionId: constructTransactionIdentifier({ transactionId: constructTransactionIdentifier({
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId: pushInc.peerPushPaymentIncomingId, peerPushCreditId: pushInc.peerPushCreditId,
}), }),
...(pushOrt?.lastError ? { error: pushOrt.lastError } : {}), ...(pushOrt?.lastError ? { error: pushOrt.lastError } : {}),
}; };
@ -654,7 +654,7 @@ function buildTransactionForBankIntegratedWithdraw(
reservePub: wgRecord.reservePub, reservePub: wgRecord.reservePub,
bankConfirmationUrl: wgRecord.wgInfo.bankInfo.confirmUrl, bankConfirmationUrl: wgRecord.wgInfo.bankInfo.confirmUrl,
reserveIsReady: reserveIsReady:
wgRecord.status === WithdrawalGroupStatus.Finished || wgRecord.status === WithdrawalGroupStatus.Done ||
wgRecord.status === WithdrawalGroupStatus.PendingReady, wgRecord.status === WithdrawalGroupStatus.PendingReady,
}, },
kycUrl: wgRecord.kycUrl, kycUrl: wgRecord.kycUrl,
@ -698,7 +698,7 @@ function buildTransactionForManualWithdraw(
reservePub: withdrawalGroup.reservePub, reservePub: withdrawalGroup.reservePub,
exchangePaytoUris, exchangePaytoUris,
reserveIsReady: reserveIsReady:
withdrawalGroup.status === WithdrawalGroupStatus.Finished || withdrawalGroup.status === WithdrawalGroupStatus.Done ||
withdrawalGroup.status === WithdrawalGroupStatus.PendingReady, withdrawalGroup.status === WithdrawalGroupStatus.PendingReady,
}, },
kycUrl: withdrawalGroup.kycUrl, kycUrl: withdrawalGroup.kycUrl,
@ -944,10 +944,10 @@ export async function getTransactions(
x.exchangeDetails, x.exchangeDetails,
x.exchanges, x.exchanges,
x.operationRetries, x.operationRetries,
x.peerPullPaymentIncoming, x.peerPullDebit,
x.peerPushPaymentInitiations, x.peerPushDebit,
x.peerPushPaymentIncoming, x.peerPushCredit,
x.peerPullPaymentInitiations, x.peerPullCredit,
x.planchets, x.planchets,
x.purchases, x.purchases,
x.contractTerms, x.contractTerms,
@ -985,7 +985,7 @@ export async function getTransactions(
} }
if ( if (
pi.status !== PeerPullDebitRecordStatus.PendingDeposit && pi.status !== PeerPullDebitRecordStatus.PendingDeposit &&
pi.status !== PeerPullDebitRecordStatus.DonePaid pi.status !== PeerPullDebitRecordStatus.Done
) { ) {
return; return;
} }
@ -1004,7 +1004,7 @@ export async function getTransactions(
if (shouldSkipSearch(transactionsRequest, [])) { if (shouldSkipSearch(transactionsRequest, [])) {
return; return;
} }
if (pi.status === PeerPushPaymentIncomingStatus.DialogProposed) { if (pi.status === PeerPushCreditStatus.DialogProposed) {
// We don't report proposed push credit transactions, user needs // We don't report proposed push credit transactions, user needs
// to scan URI again and confirm to see it. // to scan URI again and confirm to see it.
return; return;
@ -1268,9 +1268,9 @@ export async function getTransactions(
export type ParsedTransactionIdentifier = export type ParsedTransactionIdentifier =
| { tag: TransactionType.Deposit; depositGroupId: string } | { tag: TransactionType.Deposit; depositGroupId: string }
| { tag: TransactionType.Payment; proposalId: string } | { tag: TransactionType.Payment; proposalId: string }
| { tag: TransactionType.PeerPullDebit; peerPullPaymentIncomingId: string } | { tag: TransactionType.PeerPullDebit; peerPullDebitId: string }
| { tag: TransactionType.PeerPullCredit; pursePub: string } | { tag: TransactionType.PeerPullCredit; pursePub: string }
| { tag: TransactionType.PeerPushCredit; peerPushPaymentIncomingId: string } | { tag: TransactionType.PeerPushCredit; peerPushCreditId: string }
| { tag: TransactionType.PeerPushDebit; pursePub: string } | { tag: TransactionType.PeerPushDebit; pursePub: string }
| { tag: TransactionType.Refresh; refreshGroupId: string } | { tag: TransactionType.Refresh; refreshGroupId: string }
| { tag: TransactionType.Refund; refundGroupId: string } | { tag: TransactionType.Refund; refundGroupId: string }
@ -1289,9 +1289,9 @@ export function constructTransactionIdentifier(
case TransactionType.PeerPullCredit: case TransactionType.PeerPullCredit:
return `txn:${pTxId.tag}:${pTxId.pursePub}` as TransactionIdStr; return `txn:${pTxId.tag}:${pTxId.pursePub}` as TransactionIdStr;
case TransactionType.PeerPullDebit: case TransactionType.PeerPullDebit:
return `txn:${pTxId.tag}:${pTxId.peerPullPaymentIncomingId}` as TransactionIdStr; return `txn:${pTxId.tag}:${pTxId.peerPullDebitId}` as TransactionIdStr;
case TransactionType.PeerPushCredit: case TransactionType.PeerPushCredit:
return `txn:${pTxId.tag}:${pTxId.peerPushPaymentIncomingId}` as TransactionIdStr; return `txn:${pTxId.tag}:${pTxId.peerPushCreditId}` as TransactionIdStr;
case TransactionType.PeerPushDebit: case TransactionType.PeerPushDebit:
return `txn:${pTxId.tag}:${pTxId.pursePub}` as TransactionIdStr; return `txn:${pTxId.tag}:${pTxId.pursePub}` as TransactionIdStr;
case TransactionType.Refresh: case TransactionType.Refresh:
@ -1337,12 +1337,12 @@ export function parseTransactionIdentifier(
case TransactionType.PeerPullDebit: case TransactionType.PeerPullDebit:
return { return {
tag: TransactionType.PeerPullDebit, tag: TransactionType.PeerPullDebit,
peerPullPaymentIncomingId: rest[0], peerPullDebitId: rest[0],
}; };
case TransactionType.PeerPushCredit: case TransactionType.PeerPushCredit:
return { return {
tag: TransactionType.PeerPushCredit, tag: TransactionType.PeerPushCredit,
peerPushPaymentIncomingId: rest[0], peerPushCreditId: rest[0],
}; };
case TransactionType.PeerPushDebit: case TransactionType.PeerPushDebit:
return { tag: TransactionType.PeerPushDebit, pursePub: rest[0] }; return { tag: TransactionType.PeerPushDebit, pursePub: rest[0] };
@ -1455,7 +1455,7 @@ export async function retryTransaction(
case TransactionType.PeerPullDebit: { case TransactionType.PeerPullDebit: {
const taskId = constructTaskIdentifier({ const taskId = constructTaskIdentifier({
tag: PendingTaskType.PeerPullDebit, tag: PendingTaskType.PeerPullDebit,
peerPullPaymentIncomingId: parsedTx.peerPullPaymentIncomingId, peerPullDebitId: parsedTx.peerPullDebitId,
}); });
await resetPendingTaskTimeout(ws, taskId); await resetPendingTaskTimeout(ws, taskId);
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
@ -1464,7 +1464,7 @@ export async function retryTransaction(
case TransactionType.PeerPushCredit: { case TransactionType.PeerPushCredit: {
const taskId = constructTaskIdentifier({ const taskId = constructTaskIdentifier({
tag: PendingTaskType.PeerPushCredit, tag: PendingTaskType.PeerPushCredit,
peerPushPaymentIncomingId: parsedTx.peerPushPaymentIncomingId, peerPushCreditId: parsedTx.peerPushCreditId,
}); });
await resetPendingTaskTimeout(ws, taskId); await resetPendingTaskTimeout(ws, taskId);
stopLongpolling(ws, taskId); stopLongpolling(ws, taskId);
@ -1522,10 +1522,10 @@ export async function suspendTransaction(
await suspendPeerPushDebitTransaction(ws, tx.pursePub); await suspendPeerPushDebitTransaction(ws, tx.pursePub);
break; break;
case TransactionType.PeerPullDebit: case TransactionType.PeerPullDebit:
await suspendPeerPullDebitTransaction(ws, tx.peerPullPaymentIncomingId); await suspendPeerPullDebitTransaction(ws, tx.peerPullDebitId);
break; break;
case TransactionType.PeerPushCredit: case TransactionType.PeerPushCredit:
await suspendPeerPushCreditTransaction(ws, tx.peerPushPaymentIncomingId); await suspendPeerPushCreditTransaction(ws, tx.peerPushCreditId);
break; break;
case TransactionType.Refund: case TransactionType.Refund:
throw Error("refund transactions can't be suspended or resumed"); throw Error("refund transactions can't be suspended or resumed");
@ -1568,10 +1568,10 @@ export async function failTransaction(
await failPeerPullCreditTransaction(ws, tx.pursePub); await failPeerPullCreditTransaction(ws, tx.pursePub);
return; return;
case TransactionType.PeerPullDebit: case TransactionType.PeerPullDebit:
await failPeerPullDebitTransaction(ws, tx.peerPullPaymentIncomingId); await failPeerPullDebitTransaction(ws, tx.peerPullDebitId);
return; return;
case TransactionType.PeerPushCredit: case TransactionType.PeerPushCredit:
await failPeerPushCreditTransaction(ws, tx.peerPushPaymentIncomingId); await failPeerPushCreditTransaction(ws, tx.peerPushCreditId);
return; return;
case TransactionType.PeerPushDebit: case TransactionType.PeerPushDebit:
await failPeerPushDebitTransaction(ws, tx.pursePub); await failPeerPushDebitTransaction(ws, tx.pursePub);
@ -1613,10 +1613,10 @@ export async function resumeTransaction(
await resumePeerPushDebitTransaction(ws, tx.pursePub); await resumePeerPushDebitTransaction(ws, tx.pursePub);
break; break;
case TransactionType.PeerPullDebit: case TransactionType.PeerPullDebit:
await resumePeerPullDebitTransaction(ws, tx.peerPullPaymentIncomingId); await resumePeerPullDebitTransaction(ws, tx.peerPullDebitId);
break; break;
case TransactionType.PeerPushCredit: case TransactionType.PeerPushCredit:
await resumePeerPushCreditTransaction(ws, tx.peerPushPaymentIncomingId); await resumePeerPushCreditTransaction(ws, tx.peerPushCreditId);
break; break;
case TransactionType.Refund: case TransactionType.Refund:
throw Error("refund transactions can't be suspended or resumed"); throw Error("refund transactions can't be suspended or resumed");
@ -1641,16 +1641,16 @@ export async function deleteTransaction(
switch (parsedTx.tag) { switch (parsedTx.tag) {
case TransactionType.PeerPushCredit: { case TransactionType.PeerPushCredit: {
const peerPushPaymentIncomingId = parsedTx.peerPushPaymentIncomingId; const peerPushCreditId = parsedTx.peerPushCreditId;
await ws.db await ws.db
.mktx((x) => [ .mktx((x) => [
x.withdrawalGroups, x.withdrawalGroups,
x.peerPushPaymentIncoming, x.peerPushCredit,
x.tombstones, x.tombstones,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pushInc = await tx.peerPushPaymentIncoming.get( const pushInc = await tx.peerPushCredit.get(
peerPushPaymentIncomingId, peerPushCreditId,
); );
if (!pushInc) { if (!pushInc) {
return; return;
@ -1668,12 +1668,12 @@ export async function deleteTransaction(
}); });
} }
} }
await tx.peerPushPaymentIncoming.delete(peerPushPaymentIncomingId); await tx.peerPushCredit.delete(peerPushCreditId);
await tx.tombstones.put({ await tx.tombstones.put({
id: id:
TombstoneTag.DeletePeerPushCredit + TombstoneTag.DeletePeerPushCredit +
":" + ":" +
peerPushPaymentIncomingId, peerPushCreditId,
}); });
}); });
return; return;
@ -1684,11 +1684,11 @@ export async function deleteTransaction(
await ws.db await ws.db
.mktx((x) => [ .mktx((x) => [
x.withdrawalGroups, x.withdrawalGroups,
x.peerPullPaymentInitiations, x.peerPullCredit,
x.tombstones, x.tombstones,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const pullIni = await tx.peerPullPaymentInitiations.get(pursePub); const pullIni = await tx.peerPullCredit.get(pursePub);
if (!pullIni) { if (!pullIni) {
return; return;
} }
@ -1705,7 +1705,7 @@ export async function deleteTransaction(
}); });
} }
} }
await tx.peerPullPaymentInitiations.delete(pursePub); await tx.peerPullCredit.delete(pursePub);
await tx.tombstones.put({ await tx.tombstones.put({
id: TombstoneTag.DeletePeerPullCredit + ":" + pursePub, id: TombstoneTag.DeletePeerPullCredit + ":" + pursePub,
}); });
@ -1795,7 +1795,7 @@ export async function deleteTransaction(
case TransactionType.Refund: { case TransactionType.Refund: {
const refundGroupId = parsedTx.refundGroupId; const refundGroupId = parsedTx.refundGroupId;
await ws.db await ws.db
.mktx((x) => [x.refundGroups, x.tombstones, x.refundItems]) .mktx((x) => [x.refundGroups, x.tombstones])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const refundRecord = await tx.refundGroups.get(refundGroupId); const refundRecord = await tx.refundGroups.get(refundGroupId);
if (!refundRecord) { if (!refundRecord) {
@ -1809,15 +1809,15 @@ export async function deleteTransaction(
} }
case TransactionType.PeerPullDebit: { case TransactionType.PeerPullDebit: {
const peerPullPaymentIncomingId = parsedTx.peerPullPaymentIncomingId; const peerPullDebitId = parsedTx.peerPullDebitId;
await ws.db await ws.db
.mktx((x) => [x.peerPullPaymentIncoming, x.tombstones]) .mktx((x) => [x.peerPullDebit, x.tombstones])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const debit = await tx.peerPullPaymentIncoming.get( const debit = await tx.peerPullDebit.get(
peerPullPaymentIncomingId, peerPullDebitId,
); );
if (debit) { if (debit) {
await tx.peerPullPaymentIncoming.delete(peerPullPaymentIncomingId); await tx.peerPullDebit.delete(peerPullDebitId);
await tx.tombstones.put({ id: transactionId }); await tx.tombstones.put({ id: transactionId });
} }
}); });
@ -1828,11 +1828,11 @@ export async function deleteTransaction(
case TransactionType.PeerPushDebit: { case TransactionType.PeerPushDebit: {
const pursePub = parsedTx.pursePub; const pursePub = parsedTx.pursePub;
await ws.db await ws.db
.mktx((x) => [x.peerPushPaymentInitiations, x.tombstones]) .mktx((x) => [x.peerPushDebit, x.tombstones])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const debit = await tx.peerPushPaymentInitiations.get(pursePub); const debit = await tx.peerPushDebit.get(pursePub);
if (debit) { if (debit) {
await tx.peerPushPaymentInitiations.delete(pursePub); await tx.peerPushDebit.delete(pursePub);
await tx.tombstones.put({ id: transactionId }); await tx.tombstones.put({ id: transactionId });
} }
}); });
@ -1875,10 +1875,10 @@ export async function abortTransaction(
await abortPeerPullCreditTransaction(ws, txId.pursePub); await abortPeerPullCreditTransaction(ws, txId.pursePub);
break; break;
case TransactionType.PeerPullDebit: case TransactionType.PeerPullDebit:
await abortPeerPullDebitTransaction(ws, txId.peerPullPaymentIncomingId); await abortPeerPullDebitTransaction(ws, txId.peerPullDebitId);
break; break;
case TransactionType.PeerPushCredit: case TransactionType.PeerPushCredit:
await abortPeerPushCreditTransaction(ws, txId.peerPushPaymentIncomingId); await abortPeerPushCreditTransaction(ws, txId.peerPushCreditId);
break; break;
case TransactionType.PeerPushDebit: case TransactionType.PeerPushDebit:
await abortPeerPushDebitTransaction(ws, txId.pursePub); await abortPeerPushDebitTransaction(ws, txId.pursePub);

12
packages/taler-wallet-core/src/operations/withdraw.ts
View File

@ -315,7 +315,7 @@ export async function abortWithdrawalTransaction(
case WithdrawalGroupStatus.AbortingBank: case WithdrawalGroupStatus.AbortingBank:
// No transition needed, but not an error // No transition needed, but not an error
break; break;
case WithdrawalGroupStatus.Finished: case WithdrawalGroupStatus.Done:
case WithdrawalGroupStatus.FailedBankAborted: case WithdrawalGroupStatus.FailedBankAborted:
case WithdrawalGroupStatus.AbortedExchange: case WithdrawalGroupStatus.AbortedExchange:
case WithdrawalGroupStatus.AbortedBank: case WithdrawalGroupStatus.AbortedBank:
@ -395,7 +395,7 @@ export function computeWithdrawalTransactionStatus(
return { return {
major: TransactionMajorState.Aborted, major: TransactionMajorState.Aborted,
}; };
case WithdrawalGroupStatus.Finished: case WithdrawalGroupStatus.Done:
return { return {
major: TransactionMajorState.Done, major: TransactionMajorState.Done,
}; };
@ -499,7 +499,7 @@ export function computeWithdrawalTransactionActions(
switch (wgRecord.status) { switch (wgRecord.status) {
case WithdrawalGroupStatus.FailedBankAborted: case WithdrawalGroupStatus.FailedBankAborted:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case WithdrawalGroupStatus.Finished: case WithdrawalGroupStatus.Done:
return [TransactionAction.Delete]; return [TransactionAction.Delete];
case WithdrawalGroupStatus.PendingRegisteringBank: case WithdrawalGroupStatus.PendingRegisteringBank:
return [TransactionAction.Suspend, TransactionAction.Abort]; return [TransactionAction.Suspend, TransactionAction.Abort];
@ -1457,7 +1457,7 @@ async function processWithdrawalGroupPendingReady(
return undefined; return undefined;
} }
const txStatusOld = computeWithdrawalTransactionStatus(wg); const txStatusOld = computeWithdrawalTransactionStatus(wg);
wg.status = WithdrawalGroupStatus.Finished; wg.status = WithdrawalGroupStatus.Done;
wg.timestampFinish = TalerPreciseTimestamp.now(); wg.timestampFinish = TalerPreciseTimestamp.now();
const txStatusNew = computeWithdrawalTransactionStatus(wg); const txStatusNew = computeWithdrawalTransactionStatus(wg);
await tx.withdrawalGroups.put(wg); await tx.withdrawalGroups.put(wg);
@ -1555,7 +1555,7 @@ async function processWithdrawalGroupPendingReady(
logger.info(`now withdrawn ${numFinished} of ${numTotalCoins} coins`); logger.info(`now withdrawn ${numFinished} of ${numTotalCoins} coins`);
if (wg.timestampFinish === undefined && numFinished === numTotalCoins) { if (wg.timestampFinish === undefined && numFinished === numTotalCoins) {
wg.timestampFinish = TalerPreciseTimestamp.now(); wg.timestampFinish = TalerPreciseTimestamp.now();
wg.status = WithdrawalGroupStatus.Finished; wg.status = WithdrawalGroupStatus.Done;
await makeCoinsVisible(ws, tx, transactionId); await makeCoinsVisible(ws, tx, transactionId);
} }
@ -1647,7 +1647,7 @@ export async function processWithdrawalGroup(
} }
break; break;
} }
case WithdrawalGroupStatus.Finished: case WithdrawalGroupStatus.Done:
case WithdrawalGroupStatus.FailedBankAborted: { case WithdrawalGroupStatus.FailedBankAborted: {
// FIXME // FIXME
return TaskRunResult.pending(); return TaskRunResult.pending();

4
packages/taler-wallet-core/src/pending-types.ts
View File

@ -99,14 +99,14 @@ export interface PendingPeerPullInitiationTask {
*/ */
export interface PendingPeerPullDebitTask { export interface PendingPeerPullDebitTask {
type: PendingTaskType.PeerPullDebit; type: PendingTaskType.PeerPullDebit;
peerPullPaymentIncomingId: string; peerPullDebitId: string;
} }
/** /**
*/ */
export interface PendingPeerPushCreditTask { export interface PendingPeerPushCreditTask {
type: PendingTaskType.PeerPushCredit; type: PendingTaskType.PeerPushCredit;
peerPushPaymentIncomingId: string; peerPushCreditId: string;
} }
/** /**

2
packages/taler-wallet-core/src/util/coinSelection.ts
View File

@ -1002,7 +1002,7 @@ export async function selectPeerCoins(
x.coinAvailability, x.coinAvailability,
x.denominations, x.denominations,
x.refreshGroups, x.refreshGroups,
x.peerPushPaymentInitiations, x.peerPushDebit,
]) ])
.runReadWrite(async (tx) => { .runReadWrite(async (tx) => {
const exchanges = await tx.exchanges.iter().toArray(); const exchanges = await tx.exchanges.iter().toArray();

109
packages/taler-wallet-core/src/util/query.ts
View File

@ -35,7 +35,7 @@ import {
IDBKeyPath, IDBKeyPath,
IDBKeyRange, IDBKeyRange,
} from "@gnu-taler/idb-bridge"; } from "@gnu-taler/idb-bridge";
import { Logger, j2s } from "@gnu-taler/taler-util"; import { Codec, Logger, j2s } from "@gnu-taler/taler-util";
const logger = new Logger("query.ts"); const logger = new Logger("query.ts");
@ -387,11 +387,11 @@ export interface StoreReadWriteAccessor<RecordType, IndexMap> {
export interface StoreWithIndexes< export interface StoreWithIndexes<
StoreName extends string, StoreName extends string,
SD extends StoreDescriptor<unknown>, RecordType,
IndexMap, IndexMap,
> { > {
storeName: StoreName; storeName: StoreName;
store: SD; store: StoreDescriptor<RecordType>;
indexMap: IndexMap; indexMap: IndexMap;
/** /**
@ -401,19 +401,13 @@ export interface StoreWithIndexes<
mark: Symbol; mark: Symbol;
} }
export type GetRecordType<T> = T extends StoreDescriptor<infer X> ? X : unknown;
const storeWithIndexesSymbol = Symbol("StoreWithIndexesMark"); const storeWithIndexesSymbol = Symbol("StoreWithIndexesMark");
export function describeStore< export function describeStore<StoreName extends string, RecordType, IndexMap>(
StoreName extends string,
SD extends StoreDescriptor<unknown>,
IndexMap,
>(
name: StoreName, name: StoreName,
s: SD, s: StoreDescriptor<RecordType>,
m: IndexMap, m: IndexMap,
): StoreWithIndexes<StoreName, SD, IndexMap> { ): StoreWithIndexes<StoreName, RecordType, IndexMap> {
return { return {
storeName: name, storeName: name,
store: s, store: s,
@ -422,13 +416,72 @@ export function describeStore<
}; };
} }
export function describeStoreV2<
StoreName extends string,
RecordType,
IndexMap extends { [x: string]: IndexDescriptor } = {},
>(args: {
storeName: StoreName;
recordCodec: Codec<RecordType>;
keyPath?: IDBKeyPath | IDBKeyPath[];
autoIncrement?: boolean;
/**
* Database version that this store was added in, or
* undefined if added in the first version.
*/
versionAdded?: number;
indexes?: IndexMap;
}): StoreWithIndexes<StoreName, RecordType, IndexMap> {
return {
storeName: args.storeName,
store: {
_dummy: undefined as any,
autoIncrement: args.autoIncrement,
keyPath: args.keyPath,
versionAdded: args.versionAdded,
},
indexMap: args.indexes ?? ({} as IndexMap),
mark: storeWithIndexesSymbol,
};
}
type KeyPathComponents = string | number;
/**
* Follow a key path (dot-separated) in an object.
*/
type DerefKeyPath<T, P> = P extends `${infer PX extends keyof T &
KeyPathComponents}`
? T[PX]
: P extends `${infer P0 extends keyof T & KeyPathComponents}.${infer Rest}`
? DerefKeyPath<T[P0], Rest>
: unknown;
/**
* Return a path if it is a valid dot-separate path to an object.
* Otherwise, return "never".
*/
type ValidateKeyPath<T, P> = P extends `${infer PX extends keyof T &
KeyPathComponents}`
? PX
: P extends `${infer P0 extends keyof T & KeyPathComponents}.${infer Rest}`
? `${P0}.${ValidateKeyPath<T[P0], Rest>}`
: never;
// function foo<T, P>(
// x: T,
// p: P extends ValidateKeyPath<T, P> ? P : never,
// ): void {}
// foo({x: [0,1,2]}, "x.0");
export type GetReadOnlyAccess<BoundStores> = { export type GetReadOnlyAccess<BoundStores> = {
[P in keyof BoundStores]: BoundStores[P] extends StoreWithIndexes< [P in keyof BoundStores]: BoundStores[P] extends StoreWithIndexes<
infer SN, infer StoreName,
infer SD, infer RecordType,
infer IM infer IndexMap
> >
? StoreReadOnlyAccessor<GetRecordType<SD>, IM> ? StoreReadOnlyAccessor<RecordType, IndexMap>
: unknown; : unknown;
}; };
@ -446,11 +499,11 @@ export type DbReadOnlyTransaction<
} }
? { ? {
[P in Stores]: StoreMap[P] extends StoreWithIndexes< [P in Stores]: StoreMap[P] extends StoreWithIndexes<
infer SN, infer StoreName,
infer SD, infer RecordType,
infer IM infer IndexMap
> >
? StoreReadOnlyAccessor<GetRecordType<SD>, IM> ? StoreReadOnlyAccessor<RecordType, IndexMap>
: unknown; : unknown;
} }
: unknown; : unknown;
@ -463,22 +516,22 @@ export type DbReadWriteTransaction<
} }
? { ? {
[P in Stores]: StoreMap[P] extends StoreWithIndexes< [P in Stores]: StoreMap[P] extends StoreWithIndexes<
infer SN, infer StoreName,
infer SD, infer RecordType,
infer IM infer IndexMap
> >
? StoreReadWriteAccessor<GetRecordType<SD>, IM> ? StoreReadWriteAccessor<RecordType, IndexMap>
: unknown; : unknown;
} }
: unknown; : unknown;
export type GetReadWriteAccess<BoundStores> = { export type GetReadWriteAccess<BoundStores> = {
[P in keyof BoundStores]: BoundStores[P] extends StoreWithIndexes< [P in keyof BoundStores]: BoundStores[P] extends StoreWithIndexes<
infer SN, infer StoreName,
infer SD, infer RecordType,
infer IM infer IndexMap
> >
? StoreReadWriteAccessor<GetRecordType<SD>, IM> ? StoreReadWriteAccessor<RecordType, IndexMap>
: unknown; : unknown;
}; };

16
packages/taler-wallet-core/src/wallet.ts
View File

@ -354,9 +354,9 @@ async function callOperationHandler(
case PendingTaskType.PeerPullCredit: case PendingTaskType.PeerPullCredit:
return await processPeerPullCredit(ws, pending.pursePub); return await processPeerPullCredit(ws, pending.pursePub);
case PendingTaskType.PeerPullDebit: case PendingTaskType.PeerPullDebit:
return await processPeerPullDebit(ws, pending.peerPullPaymentIncomingId); return await processPeerPullDebit(ws, pending.peerPullDebitId);
case PendingTaskType.PeerPushCredit: case PendingTaskType.PeerPushCredit:
return await processPeerPushCredit(ws, pending.peerPushPaymentIncomingId); return await processPeerPushCredit(ws, pending.peerPushCreditId);
default: default:
return assertUnreachable(pending); return assertUnreachable(pending);
} }
@ -1876,7 +1876,7 @@ class InternalWalletStateImpl implements InternalWalletState {
return computeRefundTransactionState(rec); return computeRefundTransactionState(rec);
} }
case TransactionType.PeerPullCredit: case TransactionType.PeerPullCredit:
const rec = await tx.peerPullPaymentInitiations.get( const rec = await tx.peerPullCredit.get(
parsedTxId.pursePub, parsedTxId.pursePub,
); );
if (!rec) { if (!rec) {
@ -1884,8 +1884,8 @@ class InternalWalletStateImpl implements InternalWalletState {
} }
return computePeerPullCreditTransactionState(rec); return computePeerPullCreditTransactionState(rec);
case TransactionType.PeerPullDebit: { case TransactionType.PeerPullDebit: {
const rec = await tx.peerPullPaymentIncoming.get( const rec = await tx.peerPullDebit.get(
parsedTxId.peerPullPaymentIncomingId, parsedTxId.peerPullDebitId,
); );
if (!rec) { if (!rec) {
return undefined; return undefined;
@ -1893,8 +1893,8 @@ class InternalWalletStateImpl implements InternalWalletState {
return computePeerPullDebitTransactionState(rec); return computePeerPullDebitTransactionState(rec);
} }
case TransactionType.PeerPushCredit: { case TransactionType.PeerPushCredit: {
const rec = await tx.peerPushPaymentIncoming.get( const rec = await tx.peerPushCredit.get(
parsedTxId.peerPushPaymentIncomingId, parsedTxId.peerPushCreditId,
); );
if (!rec) { if (!rec) {
return undefined; return undefined;
@ -1902,7 +1902,7 @@ class InternalWalletStateImpl implements InternalWalletState {
return computePeerPushCreditTransactionState(rec); return computePeerPushCreditTransactionState(rec);
} }
case TransactionType.PeerPushDebit: { case TransactionType.PeerPushDebit: {
const rec = await tx.peerPushPaymentInitiations.get( const rec = await tx.peerPushDebit.get(
parsedTxId.pursePub, parsedTxId.pursePub,
); );
if (!rec) { if (!rec) {

4
packages/taler-wallet-webextension/src/cta/InvoicePay/state.ts
View File

@ -78,7 +78,7 @@ export function useComponentState({
const { const {
contractTerms, contractTerms,
peerPullPaymentIncomingId, peerPullDebitId,
amountEffective, amountEffective,
amountRaw, amountRaw,
} = hook.response.p2p; } = hook.response.p2p;
@ -155,7 +155,7 @@ export function useComponentState({
const resp = await api.wallet.call( const resp = await api.wallet.call(
WalletApiOperation.ConfirmPeerPullDebit, WalletApiOperation.ConfirmPeerPullDebit,
{ {
peerPullPaymentIncomingId, peerPullDebitId,
}, },
); );
onSuccess(resp.transactionId); onSuccess(resp.transactionId);

4
packages/taler-wallet-webextension/src/cta/TransferPickup/state.ts
View File

@ -58,7 +58,7 @@ export function useComponentState({
const { const {
contractTerms, contractTerms,
peerPushPaymentIncomingId, peerPushCreditId,
amountEffective, amountEffective,
amountRaw, amountRaw,
} = hook.response; } = hook.response;
@ -72,7 +72,7 @@ export function useComponentState({
const resp = await api.wallet.call( const resp = await api.wallet.call(
WalletApiOperation.ConfirmPeerPushCredit, WalletApiOperation.ConfirmPeerPushCredit,
{ {
peerPushPaymentIncomingId, peerPushCreditId,
}, },
); );
onSuccess(resp.transactionId); onSuccess(resp.transactionId);