@mintmoney/react 0.1.0-alpha.30 → 0.1.0-alpha.32

package/dist/esm/state/checkout/store.js

@@ -1,10 +1,13 @@
 import { waitForTransactionReceipt } from "@wagmi/core";
 import { create } from "zustand";
 import { immer } from "zustand/middleware/immer";
-import { getCheckoutById, getCheckoutCryptoCurrencies, } from "../../api/checkouts.js";
-import { createPaymentAttempt, createTestPaymentAttempt, createFiatPaymentAttempt, getPaymentById, } from "../../api/payments.js";
+import { getCheckoutCryptoCurrencies } from "../../api/checkouts.js";
+import { createPaymentAttempt, createTestPaymentAttempt, createFiatPaymentAttempt, getPaymentById, getRequiredSettlementConfig, } from "../../api/payments.js";
 import { PaymentStatus, } from "../../api/types.js";
 import { WagmiWalletInterface } from "../../components/wallet-selector/wallets/wagmi/index.js";
+import { resolveEvmChainId, switchEvmWalletChain, } from "../../integrations/evm-chain.js";
+import { buildWalletPaymentAttemptPayload } from "./payment-attempt.js";
+import { canCreateFreshAttempt, getAttemptFreshnessStatus, } from "./payment-lifecycle.js";
 export var ACTIONS;
 (function (ACTIONS) {
     ACTIONS["GET_CHECKOUT_CONFIG"] = "GET_CHECKOUT_CONFIG";
@@ -18,6 +21,20 @@ export var ACTIONS;
     ACTIONS["POLL_PAYMENT"] = "POLL_PAYMENT";
     ACTIONS["CHECK_CHAIN_STATUS"] = "CHECK_CHAIN_STATUS";
 })(ACTIONS || (ACTIONS = {}));
+const initialWalletPaymentState = () => ({
+    status: "idle",
+    options: [],
+    walletAddress: null,
+    selectedOptionId: null,
+    quoteId: null,
+    routeId: null,
+    sourceTxHash: null,
+    destinationTxHash: null,
+    quoteStatus: "idle",
+    quote: null,
+    quoteError: null,
+    error: null,
+});
 const initialActionState = (initialValue) => Object.values(ACTIONS).reduce((acc, action) => {
     acc[action] = initialValue;
     return acc;
@@ -26,6 +43,7 @@ export const useCheckoutStore = create()(immer((_set, _get) => ({
     checkoutId: null,
     selectedMethod: null,
     selectedCurrency: null,
+    retrySession: false,
     methods: null,
     cryptoCurrency: null,
     checkout: null,
@@ -46,11 +64,280 @@ export const useCheckoutStore = create()(immer((_set, _get) => ({
         pollCount: 0,
         lastPollTime: null,
     },
+    attemptFreshness: {
+        status: "idle",
+        expiresAt: null,
+        remainingMs: null,
+    },
+    attemptRefresh: {
+        mode: "none",
+        status: "idle",
+        error: null,
+    },
+    walletPayment: initialWalletPaymentState(),
 })));
 const set = (fn) => {
     useCheckoutStore.setState(fn);
 };
 const get = () => useCheckoutStore.getState();
+let attemptFreshnessTimer = null;
+let attemptFreshnessInterval = null;
+const clearAttemptFreshnessTimer = () => {
+    if (attemptFreshnessTimer) {
+        clearTimeout(attemptFreshnessTimer);
+        attemptFreshnessTimer = null;
+    }
+    if (attemptFreshnessInterval) {
+        clearInterval(attemptFreshnessInterval);
+        attemptFreshnessInterval = null;
+    }
+};
+const buildDirectWalletQuote = (option, attempt) => {
+    const amount = String(attempt.amount_formatted);
+    return {
+        quoteId: option.quoteId,
+        routeId: option.routeId,
+        toolName: "Direct transfer",
+        fromAmount: amount,
+        fromAmountDisplay: amount,
+        toAmount: amount,
+        toAmountDisplay: amount,
+        estimatedDurationMinutes: 1,
+    };
+};
+const setAttemptRefreshState = (update, walletUpdate) => {
+    set((state) => {
+        Object.assign(state.attemptRefresh, update);
+        if (walletUpdate) {
+            Object.assign(state.walletPayment, walletUpdate);
+        }
+    });
+};
+const getWalletQuoteLoadingState = () => ({
+    quoteStatus: "loading",
+    quote: null,
+    quoteError: null,
+    quoteId: null,
+    routeId: null,
+});
+const getWalletQuoteReadyState = (quote) => ({
+    quoteStatus: "ready",
+    quote,
+    quoteId: quote.quoteId,
+    routeId: quote.routeId,
+    quoteError: null,
+});
+const getWalletQuoteFailedState = (message) => ({
+    quoteStatus: "failed",
+    quote: null,
+    quoteError: message,
+});
+const beginAttemptRefresh = (walletUpdate) => {
+    setAttemptRefreshState({
+        status: "refreshing",
+        error: null,
+    }, walletUpdate);
+};
+const finishAttemptRefresh = (walletUpdate) => {
+    setAttemptRefreshState({
+        status: "idle",
+        error: null,
+    }, walletUpdate);
+};
+const failAttemptRefresh = (message) => {
+    const { attemptRefresh } = get();
+    setAttemptRefreshState({
+        status: "failed",
+        error: message,
+    }, attemptRefresh.mode === "wallet"
+        ? getWalletQuoteFailedState(message)
+        : undefined);
+};
+const getWalletAttemptRefreshContext = () => {
+    const state = get();
+    const payment = state.payment;
+    const checkout = state.checkout;
+    const settlementCurrency = state.cryptoCurrency;
+    const selectedOption = state.walletPayment.options.find((option) => option.id === state.walletPayment.selectedOptionId);
+    const walletAddress = state.walletPayment.walletAddress;
+    if (!payment || !checkout || !settlementCurrency) {
+        throw new Error("Wallet payment context is not ready");
+    }
+    if (!selectedOption || !walletAddress) {
+        throw new Error("Missing wallet payment selection for quote refresh");
+    }
+    return {
+        payment,
+        checkout,
+        settlementCurrency,
+        selectedOption,
+        walletAddress,
+    };
+};
+const resolveRefreshedWalletQuote = async ({ selectedOption, checkout, payment, settlementCurrency, walletAddress, attempt, }) => {
+    if (selectedOption.kind === "direct") {
+        return buildDirectWalletQuote(selectedOption, attempt);
+    }
+    // Keep routed-quote loading behind a dynamic import so the checkout store
+    // does not eagerly pull the LI.FI integration path into manual-only flows.
+    const { fetchWalletPaymentQuote } = await import("../../integrations/index.js");
+    return fetchWalletPaymentQuote({
+        option: selectedOption,
+        context: {
+            checkout,
+            payment: get().payment ?? payment,
+            settlementCurrency,
+            walletAddress,
+            cryptoPaymentAttempt: attempt,
+        },
+    });
+};
+const refreshWalletPaymentAttempt = async () => {
+    const context = getWalletAttemptRefreshContext();
+    beginAttemptRefresh(getWalletQuoteLoadingState());
+    const attempt = await createWalletOptionPaymentAttempt(context.selectedOption, context.walletAddress, null);
+    const quote = await resolveRefreshedWalletQuote({
+        ...context,
+        attempt,
+    });
+    finishAttemptRefresh(getWalletQuoteReadyState(quote));
+};
+const refreshCurrentAttempt = async () => {
+    const state = get();
+    if (state.attemptRefresh.status === "refreshing") {
+        return;
+    }
+    if (!canCreateFreshAttempt(state.payment)) {
+        return;
+    }
+    try {
+        if (state.attemptRefresh.mode === "wallet") {
+            await refreshWalletPaymentAttempt();
+            return;
+        }
+        if (state.attemptRefresh.mode === "manual") {
+            beginAttemptRefresh();
+            await createManualDirectPaymentAttempt();
+            finishAttemptRefresh();
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error
+            ? error.message
+            : "Failed to refresh payment quote";
+        failAttemptRefresh(message);
+    }
+};
+const scheduleAttemptFreshness = (payment, attempt) => {
+    clearAttemptFreshnessTimer();
+    const freshness = getAttemptFreshnessStatus(payment, attempt ?? null);
+    set((state) => {
+        state.attemptFreshness = freshness;
+    });
+    if (freshness.status !== "fresh" || !freshness.expiresAt) {
+        return;
+    }
+    // The one-shot timer is the authoritative expiry transition. When the
+    // current attempt crosses its `expires_at`, we recompute freshness against the
+    // latest payment snapshot and kick off a single refresh if the attempt is now
+    // stale.
+    const delay = Math.max(0, freshness.expiresAt - Date.now());
+    attemptFreshnessTimer = setTimeout(() => {
+        const state = get();
+        const currentAttempt = state.cryptoPaymentAttempt ?? state.payment?.payment_attempt;
+        const currentFreshness = getAttemptFreshnessStatus(state.payment, currentAttempt);
+        set((draft) => {
+            draft.attemptFreshness = currentFreshness;
+        });
+        if (currentFreshness.status === "stale") {
+            void refreshCurrentAttempt();
+        }
+    }, delay);
+    // The interval is only for UI countdown updates while an attempt is still
+    // fresh. It keeps `remainingMs` moving without waiting for the expiry timer to
+    // fire, and stops itself once the attempt is no longer usable.
+    attemptFreshnessInterval = setInterval(() => {
+        const currentState = get();
+        const currentAttempt = currentState.cryptoPaymentAttempt ??
+            currentState.payment?.payment_attempt;
+        const currentFreshness = getAttemptFreshnessStatus(currentState.payment, currentAttempt);
+        if (currentFreshness.status !== "fresh" || !currentFreshness.expiresAt) {
+            clearAttemptFreshnessTimer();
+            set((state) => {
+                state.attemptFreshness = {
+                    status: currentFreshness.status,
+                    expiresAt: currentFreshness.expiresAt,
+                    remainingMs: currentFreshness.expiresAt !== null
+                        ? 0
+                        : currentFreshness.remainingMs,
+                };
+            });
+            return;
+        }
+        set((state) => {
+            state.attemptFreshness = {
+                ...currentFreshness,
+                remainingMs: currentFreshness.remainingMs,
+            };
+        });
+    }, 1000);
+};
+export const syncCheckoutAttemptFreshness = (payment, attempt) => {
+    // Re-sync the freshness timers whenever the payment snapshot or active
+    // attempt changes. This is the single entrypoint used after loading a
+    // payment, creating a fresh attempt, or resetting session state.
+    scheduleAttemptFreshness(payment, attempt);
+};
+export const configureWalletAttemptRefresh = (walletAddress) => {
+    set((state) => {
+        // Wallet refresh mode means stale attempts should be replaced by creating a
+        // fresh crypto payment attempt and reloading wallet quote state for the
+        // currently selected wallet route.
+        state.attemptRefresh.mode = "wallet";
+        state.attemptRefresh.error = null;
+        if (state.attemptRefresh.status !== "refreshing") {
+            state.attemptRefresh.status = "idle";
+        }
+        state.walletPayment.walletAddress = walletAddress;
+    });
+};
+export const configureManualAttemptRefresh = () => {
+    set((state) => {
+        // Manual refresh mode reuses the same stale-attempt lifecycle, but the
+        // refresh path only needs a new direct/manual attempt and not any wallet
+        // quote metadata.
+        state.attemptRefresh.mode = "manual";
+        state.attemptRefresh.error = null;
+        if (state.attemptRefresh.status !== "refreshing") {
+            state.attemptRefresh.status = "idle";
+        }
+    });
+};
+export const clearAttemptRefreshContext = () => {
+    set((state) => {
+        // Clear any stale refresh mode before returning to method selection or
+        // closing the checkout so future expiry events do not try to reuse old
+        // wallet/manual context.
+        state.attemptRefresh = {
+            mode: "none",
+            status: "idle",
+            error: null,
+        };
+        state.walletPayment.walletAddress = null;
+    });
+};
+const updatePaymentSnapshot = (payment, attempt, extra) => {
+    set((state) => {
+        state.payment = payment;
+        if (attempt !== undefined) {
+            state.cryptoPaymentAttempt = attempt;
+        }
+        if (extra) {
+            extra(state);
+        }
+    });
+    syncCheckoutAttemptFreshness(payment, attempt ?? payment?.payment_attempt);
+};
 export const clearErrors = () => {
     set((state) => {
         Object.values(ACTIONS).forEach((action) => {
@@ -59,11 +346,12 @@ export const clearErrors = () => {
     });
 };
 export const initialiseStore = async (payment) => {
-    set((state) => {
-        state.payment = payment;
-    });
+    resetCheckoutStore();
+    updatePaymentSnapshot(payment);
     try {
-        await getCheckoutConfig(payment.checkout_id);
+        const refreshedPayment = await getPaymentById(payment.id);
+        updatePaymentSnapshot(refreshedPayment);
+        hydrateCheckoutFromPayment(refreshedPayment);
     }
     catch (err) {
         set((state) => {
@@ -71,24 +359,39 @@ export const initialiseStore = async (payment) => {
         });
     }
 };
-export const createCheckoutCryptoPaymentAttempt = async (currency) => {
-    const paymentId = useCheckoutStore.getState().payment?.id;
+export const createWalletOptionPaymentAttempt = async (
+// "direct" is a routing classification: the payer sends the settlement
+// asset on the settlement chain. It is not tied to manual vs wallet UX.
+option, sendingAddress, quote) => {
+    const payment = useCheckoutStore.getState().payment;
+    const paymentId = payment?.id;
     if (!paymentId) {
         throw Error("Cannot create payment attempt without payment object.");
     }
+    if (!canCreateFreshAttempt(payment)) {
+        throw Error("This payment is no longer payable.");
+    }
     try {
         set((state) => {
             state.error[ACTIONS.CREATE_PAYMENT_ATTEMPT] = null;
             state.loading[ACTIONS.CREATE_PAYMENT_ATTEMPT] = true;
         });
-        const attempt = await createPaymentAttempt(paymentId, currency, 1);
-        const payment = await getPaymentById(paymentId);
-        set((state) => {
-            state.payment = payment;
-            state.cryptoPaymentAttempt = attempt;
+        const attemptPayload = buildWalletPaymentAttemptPayload({
+            option,
+            sendingAddress,
+            quote,
+            requiredConfirmations: 1,
+        });
+        const attempt = await createPaymentAttempt(paymentId, attemptPayload, 1);
+        const refreshedPayment = await getPaymentById(paymentId);
+        updatePaymentSnapshot(refreshedPayment, attempt, (state) => {
+            state.retrySession = false;
+            state.attemptRefresh.status = "idle";
+            state.attemptRefresh.error = null;
             state.error[ACTIONS.CREATE_PAYMENT_ATTEMPT] = null;
             state.loading[ACTIONS.CREATE_PAYMENT_ATTEMPT] = false;
         });
+        return attempt;
     }
     catch (err) {
         const error = err;
@@ -96,8 +399,35 @@ export const createCheckoutCryptoPaymentAttempt = async (currency) => {
             state.error[ACTIONS.CREATE_PAYMENT_ATTEMPT] = error.message;
             state.loading[ACTIONS.CREATE_PAYMENT_ATTEMPT] = false;
         });
+        throw error;
     }
 };
+export const createManualDirectPaymentAttempt = async (sendingAddress = "", confirmations = 1) => {
+    const payment = useCheckoutStore.getState().payment;
+    const paymentId = payment?.id;
+    if (!paymentId) {
+        throw Error("Cannot create payment attempt without payment object.");
+    }
+    const settlementConfig = getRequiredSettlementConfig(payment);
+    const attempt = await createPaymentAttempt(paymentId, {
+        sendingAddress,
+        required_confirmations: confirmations,
+        routing: {
+            type: "direct",
+            source: {
+                token: settlementConfig.asset,
+                chain: settlementConfig.chain,
+            },
+        },
+    });
+    const refreshedPayment = await getPaymentById(paymentId);
+    updatePaymentSnapshot(refreshedPayment, attempt, (state) => {
+        state.retrySession = false;
+        state.attemptRefresh.status = "idle";
+        state.attemptRefresh.error = null;
+    });
+    return attempt;
+};
 export const createSuccessfulTestPaymentAttempt = async () => {
     const paymentId = useCheckoutStore.getState().payment?.id;
     if (!paymentId) {
@@ -108,11 +438,14 @@ export const createSuccessfulTestPaymentAttempt = async () => {
             state.error[ACTIONS.CREATE_TEST_PAYMENT_ATTEMPT] = null;
             state.loading[ACTIONS.CREATE_TEST_PAYMENT_ATTEMPT] = true;
         });
-        const attempt = await createTestPaymentAttempt(paymentId, "0xsuccess");
+        const currentPayment = useCheckoutStore.getState().payment;
+        if (!currentPayment) {
+            throw Error("Cannot create test payment attempt without payment object.");
+        }
+        const attempt = await createTestPaymentAttempt(paymentId, "0xsuccess", currentPayment);
         const payment = await getPaymentById(paymentId);
-        set((state) => {
-            state.payment = payment;
-            state.cryptoPaymentAttempt = attempt;
+        updatePaymentSnapshot(payment, attempt, (state) => {
+            state.retrySession = false;
             state.error[ACTIONS.CREATE_TEST_PAYMENT_ATTEMPT] = null;
             state.loading[ACTIONS.CREATE_TEST_PAYMENT_ATTEMPT] = false;
         });
@@ -136,11 +469,14 @@ export const createFailedTestPaymentAttempt = async () => {
             state.error[ACTIONS.CREATE_TEST_PAYMENT_ATTEMPT] = null;
             state.loading[ACTIONS.CREATE_TEST_PAYMENT_ATTEMPT] = true;
         });
-        const attempt = await createTestPaymentAttempt(paymentId, "0xfail");
+        const currentPayment = useCheckoutStore.getState().payment;
+        if (!currentPayment) {
+            throw Error("Cannot create test payment attempt without payment object.");
+        }
+        const attempt = await createTestPaymentAttempt(paymentId, "0xfail", currentPayment);
         const payment = await getPaymentById(paymentId);
-        set((state) => {
-            state.payment = payment;
-            state.cryptoPaymentAttempt = attempt;
+        updatePaymentSnapshot(payment, attempt, (state) => {
+            state.retrySession = false;
             state.error[ACTIONS.CREATE_TEST_PAYMENT_ATTEMPT] = null;
             state.loading[ACTIONS.CREATE_TEST_PAYMENT_ATTEMPT] = false;
         });
@@ -188,33 +524,20 @@ export function getAvailableCheckoutMethods(checkout) {
             intentName: "cryptoIntent",
         });
     }
-    if (checkout.checkout_config.card?.enabled) {
-        methods.push({
-            name: "Pay by Card",
-            intentName: "cardIntent",
-        });
-    }
-    if (checkout.checkout_config.bank?.enabled) {
-        methods.push({
-            name: "Pay by Bank",
-            intentName: "bankIntent",
-        });
-    }
     return methods;
 }
-export const getCheckoutConfig = async (checkoutId) => {
+export const hydrateCheckoutFromPayment = (payment) => {
     const ACTION = ACTIONS.GET_CHECKOUT_CONFIG;
     set((state) => {
         state.loading[ACTION] = true;
         state.error[ACTION] = null;
     });
     try {
-        const resp = await getCheckoutById(checkoutId);
-        if (resp) {
+        if (payment.checkout) {
             set((state) => {
-                state.checkout = resp;
-                state.methods = getAvailableCheckoutMethods(resp);
-                state.cryptoCurrency = getCheckoutCryptoCurrencies(resp);
+                state.checkout = payment.checkout;
+                state.methods = getAvailableCheckoutMethods(payment.checkout);
+                state.cryptoCurrency = getCheckoutCryptoCurrencies(payment.checkout);
                 state.loading[ACTION] = false;
                 state.error[ACTION] = null;
             });
@@ -250,11 +573,12 @@ export const getPayment = async () => {
     try {
         const resp = await getPaymentById(payment.id);
         if (resp) {
+            updatePaymentSnapshot(resp);
             set((state) => {
-                state.payment = resp;
                 state.loading[ACTION] = false;
                 state.error[ACTION] = null;
             });
+            hydrateCheckoutFromPayment(resp);
             return resp;
         }
         else {
@@ -277,7 +601,7 @@ export const executeTransfer = async (wallet) => {
     const ACTION = ACTIONS.EXECUTE_TRANSFER;
     const state = get();
     console.log("[Execute Transfer] State:", state);
-    if (!state.cryptoPaymentAttempt || !state.selectedCurrency) {
+    if (!state.cryptoPaymentAttempt) {
         throw new Error("Missing required data for payment execution");
     }
     set((state) => {
@@ -287,6 +611,14 @@ export const executeTransfer = async (wallet) => {
         state.transfer.error = null;
     });
     try {
+        const settlementChainHex = state.cryptoPaymentAttempt.settlement_config.chain_hex;
+        const targetChainId = resolveEvmChainId(settlementChainHex);
+        if (targetChainId && wallet.switchChain) {
+            await wallet.switchChain(targetChainId);
+        }
+        else {
+            await switchEvmWalletChain(settlementChainHex);
+        }
         const address = await wallet.getAddress();
         if (!address) {
             throw new Error("Failed to get wallet address");
@@ -297,7 +629,7 @@ export const executeTransfer = async (wallet) => {
             amount: Number(state.cryptoPaymentAttempt.amount),
             evm: {
                 implementationAddress: state.cryptoPaymentAttempt.settlement_token_address,
-                assetName: state.selectedCurrency.asset,
+                assetName: state.cryptoPaymentAttempt.settlement_config.asset_name,
             },
         };
         const txHash = await wallet.executeTransfer(transfer);
@@ -373,6 +705,25 @@ export const resetTransfer = () => {
         };
     });
 };
+export const executeConnectedWalletPayment = async (wallet) => {
+    await executeTransfer(wallet);
+    void checkChainStatus(wallet);
+    await waitForTransferSuccess();
+};
+function waitForTransferSuccess() {
+    return new Promise((resolve, reject) => {
+        const unsubscribe = useCheckoutStore.subscribe((state) => {
+            if (state.transfer.chainStatus === "confirmed") {
+                unsubscribe();
+                resolve();
+            }
+            else if (state.transfer.chainStatus === "failed") {
+                unsubscribe();
+                reject(new Error(state.transfer.error || "Transaction failed on chain"));
+            }
+        });
+    });
+}
 export const startPaymentPolling = (onPaymentStatusChange, confirmationStatus = PaymentStatus.PAID) => {
     const ACTION = ACTIONS.POLL_PAYMENT;
     const POLL_INTERVAL = 5000;
@@ -439,17 +790,29 @@ export const stopPaymentPolling = () => {
     });
 };
 export const resetCheckoutStore = () => {
+    clearAttemptFreshnessTimer();
     set((state) => {
         Object.assign(state, {
             amount: null,
             checkoutId: null,
             selectedMethod: null,
             selectedCurrency: null,
+            retrySession: false,
             methods: null,
             cryptoCurrency: null,
             checkout: null,
             payment: null,
             cryptoPaymentAttempt: null,
+            attemptFreshness: {
+                status: "idle",
+                expiresAt: null,
+                remainingMs: null,
+            },
+            attemptRefresh: {
+                mode: "none",
+                status: "idle",
+                error: null,
+            },
             loading: initialActionState(false),
             error: initialActionState(null),
             transfer: {
@@ -463,9 +826,59 @@ export const resetCheckoutStore = () => {
                 pollCount: 0,
                 lastPollTime: null,
             },
+            walletPayment: initialWalletPaymentState(),
         });
     });
 };
+export const resetCheckoutSessionForRetry = () => {
+    clearAttemptFreshnessTimer();
+    set((state) => {
+        // Retry keeps the same payment intent but discards all attempt-scoped UI
+        // state so the payer can choose a fresh route. The payment object itself is
+        // preserved elsewhere in the store; this reset only clears execution state
+        // that was tied to the previous attempt.
+        state.selectedMethod = null;
+        state.selectedCurrency = null;
+        state.retrySession = true;
+        state.cryptoPaymentAttempt = null;
+        state.fiatPaymentAttempt = null;
+        state.processing = false;
+        state.transfer = {
+            status: "idle",
+            error: null,
+            transactionHash: null,
+            chainStatus: "pending",
+        };
+        state.polling = {
+            isPolling: false,
+            pollCount: 0,
+            lastPollTime: null,
+        };
+        state.walletPayment = initialWalletPaymentState();
+        state.attemptFreshness = {
+            status: "idle",
+            expiresAt: null,
+            remainingMs: null,
+        };
+        state.attemptRefresh = {
+            mode: "none",
+            status: "idle",
+            error: null,
+        };
+        state.error[ACTIONS.CREATE_PAYMENT_ATTEMPT] = null;
+        state.error[ACTIONS.CREATE_FIAT_PAYMENT_ATTEMPT] = null;
+        state.error[ACTIONS.CREATE_TEST_PAYMENT_ATTEMPT] = null;
+        state.error[ACTIONS.EXECUTE_TRANSFER] = null;
+        state.error[ACTIONS.POLL_PAYMENT] = null;
+        state.error[ACTIONS.CHECK_CHAIN_STATUS] = null;
+        state.loading[ACTIONS.CREATE_PAYMENT_ATTEMPT] = false;
+        state.loading[ACTIONS.CREATE_FIAT_PAYMENT_ATTEMPT] = false;
+        state.loading[ACTIONS.CREATE_TEST_PAYMENT_ATTEMPT] = false;
+        state.loading[ACTIONS.EXECUTE_TRANSFER] = false;
+        state.loading[ACTIONS.POLL_PAYMENT] = false;
+        state.loading[ACTIONS.CHECK_CHAIN_STATUS] = false;
+    });
+};
 export const setCheckoutMethod = (method) => {
     set((state) => {
         state.selectedMethod = method;
@@ -491,4 +904,14 @@ export const isTestMode = () => {
     }
     return false;
 };
+export const setWalletPaymentState = (update) => {
+    set((state) => {
+        Object.assign(state.walletPayment, update);
+    });
+};
+export const resetWalletPaymentState = () => {
+    set((state) => {
+        state.walletPayment = initialWalletPaymentState();
+    });
+};
 //# sourceMappingURL=store.js.map