@bananapus/nana-sdk-core 6.1.0 → 6.3.0

package/dist/esm/review/safeRelayr.js

@@ -5,6 +5,7 @@ import { SAFE_EXEC_ABI, canonicalSafeTxHash, requireSafeExecutionSuccess, safeEx
 import { RELAYR_API, RELAYR_UUID_RE, MAX_RELAYR_SENT_PAYMENTS, atCanonicalFinalizedBlock, bindRelayrQuote, readRelayrBundle, relayrBundleRequest, relayrPaymentOptions, relayrPaymentDetails, relayrPaymentAttemptOutcome, relayrDestinationHash, relayrDestinationHashes, relayrRetryOption, relayrSentPaymentsSnapshot, relayrStateIsPending, relayrStateIsFailed, relayrDeadlinePassed, relayrQuotedOptions, relayrQuoteUnfundable, RelayrPaymentRetryError, requireRelayrBundleUnpaid, requireRelayrRetry, revertedRelayrQuote, verifyRelayrDestinations, verifyRelayrDestination, verifyRelayrPayment, RelayrPaymentRevertedError, RelayrProofUnavailableError, } from "./relayr.js";
 import { ReviewFixedLineError } from "./lineError.js";
 import { TAB, tabShared } from "./tabState.js";
+import { assertLocksHeld, keepOutcome, LockLostError, } from "./locks.js";
 function hasFundingRecords(records) {
     if (records === undefined)
         return false;
@@ -331,14 +332,28 @@ export function createSafeRelayrController(options) {
      * `fundingObservedAt` another flow saved. Nothing ever clears them; an
      * exit keeps them for reconciliation.
      */
+    /** The locks each account's `withLock` holds, while it runs. */
+    const storeLocks = new Map();
     const store = {
         get scope() {
             return options.store.scope;
         },
         list: (account) => options.store.list(account),
-        withLock: (account, run) => options.store.withLock(account, run),
+        withLock: (account, run) => options.store.withLock(account, async (locks) => {
+            const key = account.toLowerCase();
+            const outer = storeLocks.get(key);
+            storeLocks.set(key, locks);
+            try {
+                return await run(locks);
+            }
+            finally {
+                storeLocks.set(key, outer);
+            }
+        }),
         async save(next) {
             const saved = (await options.store.list(next.account)).find((session) => session.id === next.id);
+            // Under the store's lock: still this tab's after every read, right before the write.
+            await assertLocksHeld(storeLocks.get(next.account.toLowerCase()));
             const at = [saved?.fundingObservedAt, next.fundingObservedAt].filter((value) => typeof value === "number");
             // Once seen, funding stays, and its clock only moves forward.
             return options.store.save(saved?.fundingObserved || next.fundingObserved
@@ -1204,179 +1219,234 @@ export function createSafeRelayrController(options) {
         });
     }
     async function fund({ account, sessionId, paymentChainId, signal, onStatus, }) {
-        return store.withLock(account, async () => {
-            checkAccount(account, signal);
-            let session = await load(account, sessionId);
-            const checked = await inspect(session, signal);
-            session = checked.session;
-            if (checked.state !== "ready")
-                throw new SafeRelayrRecoveryError(session, checked.recovery?.message, checked.recovery);
-            if (session.payments.length >= MAX_RELAYR_SENT_PAYMENTS)
-                throw new SafeRelayrRecoveryError(session, "This quote has reached its saved payment attempt limit. Check the existing bundle.");
-            const payment = checked.payments.find((option) => option.chain === paymentChainId);
-            if (!payment)
-                throw new Error("Choose a current payment option from this saved quote.");
-            await assertUnreserved(account, session.executions, session.id);
-            if (!reviewedIntents.has(reviewKey(session))) {
-                phase("reviewing", session, signal);
-                await options.review(session.executions, { resumed: true });
-                checkAccount(account, signal);
-                rememberReview(session);
-            }
-            let verified = false;
-            let sending = false;
-            let paymentPersisted = false;
-            const requireOpenPayment = () => relayrPaymentDetails(payment, {
-                bundleUuid: session.bundleUuid,
-                destinationChainIds: session.executions.map(({ entry }) => entry.chain),
+        // Once this attempt saved "sending", every later save goes through
+        // `keep` (`keepOutcome`): one refused for a lost lock leaves what it
+        // would have saved (the attempt's outcome) to `settle`, applied once the
+        // store's locks are taken back, to the saved record only while it is
+        // still this attempt's. The caller still gets a `LockLostError`.
+        const key = account.toLowerCase();
+        const keep = async (next, settle) => {
+            const locks = storeLocks.get(key);
+            const saved = await keepOutcome(locks, () => store.save(next), async () => {
+                // The save path checks the same locks, taken back.
+                const before = storeLocks.get(key);
+                storeLocks.set(key, locks);
+                try {
+                    const settled = settle(await load(account, sessionId));
+                    if (settled)
+                        await store.save(settled);
+                }
+                finally {
+                    storeLocks.set(key, before);
+                }
             });
-            const beforeSend = async () => {
-                phase("payment-checking", session, signal);
-                await revalidate(session.executions, account, onStatus, true, signal);
+            if (!saved)
+                throw new LockLostError(locks[0].name);
+        };
+        return funding();
+        async function funding() {
+            return store.withLock(account, async () => {
+                checkAccount(account, signal);
+                let session = await load(account, sessionId);
+                const checked = await inspect(session, signal);
+                session = checked.session;
+                if (checked.state !== "ready")
+                    throw new SafeRelayrRecoveryError(session, checked.recovery?.message, checked.recovery);
+                if (session.payments.length >= MAX_RELAYR_SENT_PAYMENTS)
+                    throw new SafeRelayrRecoveryError(session, "This quote has reached its saved payment attempt limit. Check the existing bundle.");
+                const payment = checked.payments.find((option) => option.chain === paymentChainId);
+                if (!payment)
+                    throw new Error("Choose a current payment option from this saved quote.");
                 await assertUnreserved(account, session.executions, session.id);
-                await statusRead(() => session.payments.length
-                    ? requireRelayrRetry(options.clientFor, {
-                        payments: session.payments,
-                        from: account,
-                        bundleUuid: session.bundleUuid,
-                    }, { fetch: fetchRelayr })
-                    : requireRelayrBundleUnpaid(session.bundleUuid, {
-                        fetch: fetchRelayr,
-                    })).catch(async (error) => {
-                    if (statusUnknown(error))
-                        throw unknownStatus(session);
-                    if (fundingReported(error))
-                        session = await observed(session);
-                    throw error;
+                if (!reviewedIntents.has(reviewKey(session))) {
+                    phase("reviewing", session, signal);
+                    await options.review(session.executions, { resumed: true });
+                    checkAccount(account, signal);
+                    rememberReview(session);
+                }
+                let verified = false;
+                let sending = false;
+                let paymentPersisted = false;
+                const requireOpenPayment = () => relayrPaymentDetails(payment, {
+                    bundleUuid: session.bundleUuid,
+                    destinationChainIds: session.executions.map(({ entry }) => entry.chain),
                 });
-                checkAccount(account, signal);
-                requireOpenPayment();
-                verified = true;
-            };
-            const onSending = async () => {
-                checkAccount(account, signal);
-                if (!verified || sending)
-                    throw new Error("Recheck the Safe execution before funding it.");
-                // The saved record, read again just before the wallet opens: funding
-                // another flow reported, or any change to its payment, refuses.
-                const stored = await load(account, session.id);
-                if (hasObservedFunding(stored) ||
-                    stored.state !== session.state ||
-                    stored.paymentStatus !== session.paymentStatus ||
-                    stored.bundleUuid !== session.bundleUuid ||
-                    JSON.stringify(stored.payments) !== JSON.stringify(session.payments))
-                    throw new SafeRelayrRecoveryError(stored, hasObservedFunding(stored)
-                        ? SAFE_RELAYR_FUNDING_EXIT_LINE
-                        : "This saved selection changed while it was being paid. Check it again before paying.");
-                session = { ...session, paymentStatus: "sending" };
-                await store.save(session);
-                try {
+                const beforeSend = async () => {
+                    phase("payment-checking", session, signal);
+                    await revalidate(session.executions, account, onStatus, true, signal);
+                    await assertUnreserved(account, session.executions, session.id);
+                    await statusRead(() => session.payments.length
+                        ? requireRelayrRetry(options.clientFor, {
+                            payments: session.payments,
+                            from: account,
+                            bundleUuid: session.bundleUuid,
+                        }, { fetch: fetchRelayr })
+                        : requireRelayrBundleUnpaid(session.bundleUuid, {
+                            fetch: fetchRelayr,
+                        })).catch(async (error) => {
+                        if (statusUnknown(error))
+                            throw unknownStatus(session);
+                        if (fundingReported(error))
+                            session = await observed(session);
+                        throw error;
+                    });
                     checkAccount(account, signal);
                     requireOpenPayment();
-                }
-                catch (error) {
+                    verified = true;
+                };
+                /**
+                 * Nothing was sent after "sending" was saved: the status before this
+                 * attempt again. A lost lock leaves it to the fresh-lock reconcile,
+                 * and the caller still gets the reason nothing was sent.
+                 */
+                const restoreUnsent = async () => {
                     session = {
                         ...session,
                         paymentStatus: checked.session.paymentStatus,
                     };
+                    const restored = session;
+                    await keep(restored, (current) => current.paymentStatus === "sending" &&
+                        current.bundleUuid === restored.bundleUuid &&
+                        JSON.stringify(current.payments) ===
+                            JSON.stringify(restored.payments)
+                        ? { ...current, paymentStatus: restored.paymentStatus }
+                        : undefined).catch((saveError) => {
+                        if (!(saveError instanceof LockLostError))
+                            throw saveError;
+                    });
+                };
+                const onSending = async () => {
+                    checkAccount(account, signal);
+                    if (!verified || sending)
+                        throw new Error("Recheck the Safe execution before funding it.");
+                    // The saved record, read again just before the wallet opens: funding
+                    // another flow reported, or any change to its payment, refuses.
+                    const stored = await load(account, session.id);
+                    if (hasObservedFunding(stored) ||
+                        stored.state !== session.state ||
+                        stored.paymentStatus !== session.paymentStatus ||
+                        stored.bundleUuid !== session.bundleUuid ||
+                        JSON.stringify(stored.payments) !== JSON.stringify(session.payments))
+                        throw new SafeRelayrRecoveryError(stored, hasObservedFunding(stored)
+                            ? SAFE_RELAYR_FUNDING_EXIT_LINE
+                            : "This saved selection changed while it was being paid. Check it again before paying.");
+                    session = { ...session, paymentStatus: "sending" };
                     await store.save(session);
-                    throw error;
-                }
-                sending = true;
-                phase("payment-submitting", session, signal);
-            };
-            const onSent = async (payments) => {
-                const snapshot = relayrSentPaymentsSnapshot(payments);
-                if (!sending ||
-                    !snapshot?.length ||
-                    snapshot.some((item) => item.bundleUuid !== session.bundleUuid))
-                    throw new Error("The payment does not match the saved Safe bundle.");
-                if (!snapshot.some((item) => !checked.session.payments.some((prior) => prior.hash.toLowerCase() === item.hash.toLowerCase())))
-                    throw new Error("The new payment attempt has no new transaction hash.");
-                for (const prior of session.payments) {
-                    if (!snapshot.some((item) => item.hash.toLowerCase() === prior.hash.toLowerCase() &&
-                        item.chainId === prior.chainId &&
-                        item.calldata.toLowerCase() === prior.calldata.toLowerCase() &&
-                        item.amount === prior.amount &&
-                        item.deadline === prior.deadline &&
-                        item.target.toLowerCase() === prior.target.toLowerCase()))
-                        throw new Error("The saved payment history must retain every known payment.");
-                }
-                const details = relayrPaymentDetails(payment, {
-                    bundleUuid: session.bundleUuid,
-                    destinationChainIds: session.executions.map(({ entry }) => entry.chain),
-                    nowSeconds: 0,
-                });
-                for (const item of snapshot.filter((item) => !session.payments.some((prior) => prior.hash === item.hash))) {
-                    if (item.chainId !== details.chainId ||
-                        BigInt(item.amount) !== details.amount ||
-                        BigInt(item.deadline) !== details.deadline ||
-                        item.calldata.toLowerCase() !== details.calldata.toLowerCase() ||
-                        item.target.toLowerCase() !== details.target.toLowerCase())
-                        throw new Error("The funding payment differs from the selected Relayr option.");
-                }
-                paymentPersisted = false;
-                session = {
-                    ...session,
-                    payments: structuredClone(payments),
-                    paymentStatus: "submitted",
+                    try {
+                        checkAccount(account, signal);
+                        requireOpenPayment();
+                    }
+                    catch (error) {
+                        await restoreUnsent();
+                        throw error;
+                    }
+                    sending = true;
+                    phase("payment-submitting", session, signal);
                 };
-                await store.save(session);
-                paymentPersisted = true;
-                phase("payment-confirming", session, signal);
-            };
-            try {
-                phase("payment-review", session, signal);
-                const sent = await options.sendPayment({
-                    session: structuredClone(session),
-                    payment,
-                    beforeSend,
-                    onSending,
-                    onSent,
-                });
-                if (!sent.payments.some((item) => item.hash.toLowerCase() === sent.hash.toLowerCase()))
-                    throw new Error("The funding result omitted its transaction hash.");
-                await onSent(sent.payments);
-            }
-            catch (error) {
-                if (sending &&
-                    // Classify only this attempt; restoring the previous status below
-                    // preserves the quote's earlier payments and their retry policy.
-                    relayrPaymentAttemptOutcome(error, { sending, paid: false }) ===
-                        "unpaid" &&
-                    session.payments.length === checked.session.payments.length) {
+                const onSent = async (payments) => {
+                    const snapshot = relayrSentPaymentsSnapshot(payments);
+                    if (!sending ||
+                        !snapshot?.length ||
+                        snapshot.some((item) => item.bundleUuid !== session.bundleUuid))
+                        throw new Error("The payment does not match the saved Safe bundle.");
+                    if (!snapshot.some((item) => !checked.session.payments.some((prior) => prior.hash.toLowerCase() === item.hash.toLowerCase())))
+                        throw new Error("The new payment attempt has no new transaction hash.");
+                    for (const prior of session.payments) {
+                        if (!snapshot.some((item) => item.hash.toLowerCase() === prior.hash.toLowerCase() &&
+                            item.chainId === prior.chainId &&
+                            item.calldata.toLowerCase() ===
+                                prior.calldata.toLowerCase() &&
+                            item.amount === prior.amount &&
+                            item.deadline === prior.deadline &&
+                            item.target.toLowerCase() === prior.target.toLowerCase()))
+                            throw new Error("The saved payment history must retain every known payment.");
+                    }
+                    const details = relayrPaymentDetails(payment, {
+                        bundleUuid: session.bundleUuid,
+                        destinationChainIds: session.executions.map(({ entry }) => entry.chain),
+                        nowSeconds: 0,
+                    });
+                    for (const item of snapshot.filter((item) => !session.payments.some((prior) => prior.hash === item.hash))) {
+                        if (item.chainId !== details.chainId ||
+                            BigInt(item.amount) !== details.amount ||
+                            BigInt(item.deadline) !== details.deadline ||
+                            item.calldata.toLowerCase() !== details.calldata.toLowerCase() ||
+                            item.target.toLowerCase() !== details.target.toLowerCase())
+                            throw new Error("The funding payment differs from the selected Relayr option.");
+                    }
+                    paymentPersisted = false;
                     session = {
                         ...session,
-                        paymentStatus: checked.session.paymentStatus,
+                        payments: structuredClone(payments),
+                        paymentStatus: "submitted",
                     };
-                    await store.save(session);
-                    throw error;
+                    const sent = session.payments;
+                    await keep(session, (current) => {
+                        const missing = sent.filter((item) => !current.payments.some((prior) => prior.hash.toLowerCase() === item.hash.toLowerCase()));
+                        return current.bundleUuid === session.bundleUuid &&
+                            (missing.length || current.paymentStatus === "sending")
+                            ? {
+                                ...current,
+                                payments: [...current.payments, ...missing],
+                                paymentStatus: current.paymentStatus === "sending" ||
+                                    current.paymentStatus === "unfunded"
+                                    ? "submitted"
+                                    : current.paymentStatus,
+                            }
+                            : undefined;
+                    });
+                    paymentPersisted = true;
+                    phase("payment-confirming", session, signal);
+                };
+                try {
+                    phase("payment-review", session, signal);
+                    const sent = await options.sendPayment({
+                        session: structuredClone(session),
+                        payment,
+                        beforeSend,
+                        onSending,
+                        onSent,
+                    });
+                    if (!sent.payments.some((item) => item.hash.toLowerCase() === sent.hash.toLowerCase()))
+                        throw new Error("The funding result omitted its transaction hash.");
+                    await onSent(sent.payments);
                 }
-                if (sending ||
-                    session.payments.length > checked.session.payments.length) {
-                    // A saved hash may already have funded or completed the bundle even
-                    // when the wallet adapter could not prove it. Inspect once, read-only;
-                    // never turn an uncertain or unsaved attempt into a retry invitation.
-                    if (paymentPersisted) {
-                        try {
-                            const inspected = await inspect(session, signal);
-                            session = inspected.session;
-                            if (inspected.state === "complete" ||
-                                (inspected.state === "pending" &&
-                                    session.paymentStatus === "confirmed"))
-                                return inspected;
-                        }
-                        catch (inspectionError) {
-                            if (inspectionError instanceof SafeRelayrRecoveryError)
-                                session = inspectionError.session;
+                catch (error) {
+                    if (sending &&
+                        // Classify only this attempt; restoring the previous status below
+                        // preserves the quote's earlier payments and their retry policy.
+                        relayrPaymentAttemptOutcome(error, { sending, paid: false }) ===
+                            "unpaid" &&
+                        session.payments.length === checked.session.payments.length) {
+                        await restoreUnsent();
+                        throw error;
+                    }
+                    if (sending ||
+                        session.payments.length > checked.session.payments.length) {
+                        // A saved hash may already have funded or completed the bundle even
+                        // when the wallet adapter could not prove it. Inspect once, read-only;
+                        // never turn an uncertain or unsaved attempt into a retry invitation.
+                        if (paymentPersisted) {
+                            try {
+                                const inspected = await inspect(session, signal);
+                                session = inspected.session;
+                                if (inspected.state === "complete" ||
+                                    (inspected.state === "pending" &&
+                                        session.paymentStatus === "confirmed"))
+                                    return inspected;
+                            }
+                            catch (inspectionError) {
+                                if (inspectionError instanceof SafeRelayrRecoveryError)
+                                    session = inspectionError.session;
+                            }
                         }
+                        throw new SafeRelayrRecoveryError(session, error instanceof Error ? error.message : undefined);
                     }
-                    throw new SafeRelayrRecoveryError(session, error instanceof Error ? error.message : undefined);
+                    throw error;
                 }
-                throw error;
-            }
-            return inspect(session, signal);
-        });
+                return inspect(session, signal);
+            });
+        }
     }
     /** Read-only progress polling; each read releases its lock before the wait. */
     async function watch({ account, sessionId, signal, onUpdate, intervalMs = 2_500, timeoutMs = 300_000, }) {