@bananapus/nana-sdk-core 6.0.0 → 6.2.0

package/dist/cjs/review/safeRelayr.js

@@ -15,6 +15,7 @@ const safeService_js_1 = require("../safeService.js");
 const relayr_js_1 = require("./relayr.js");
 const lineError_js_1 = require("./lineError.js");
 const tabState_js_1 = require("./tabState.js");
+const locks_js_1 = require("./locks.js");
 function hasFundingRecords(records) {
     if (records === undefined)
         return false;
@@ -74,6 +75,15 @@ function canReplaceSafeRelayrQuote(session) {
         return false;
     }
 }
+const SAFE_RELAYR_VIEW = {
+    phase: null,
+    checks: {},
+    executions: {},
+    result: null,
+    running: null,
+    error: null,
+    session: null,
+};
 /** The line a Safe action shows when its payment's status couldn't be read. */
 exports.SAFE_RELAYR_STATUS_UNKNOWN_LINE = "Couldn't check this payment's status. Try again in a moment.";
 /** The line a Safe action shows when its quote can no longer be paid but hasn't expired onchain. */
@@ -333,14 +343,28 @@ 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 (0, locks_js_1.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
@@ -354,7 +378,23 @@ function createSafeRelayrController(options) {
     };
     const fetchRelayr = options.fetch ?? globalThis.fetch;
     const displayedExecutions = new Map();
-    const notify = (progress, rechecking = false) => {
+    let view = SAFE_RELAYR_VIEW;
+    /** The calls in flight with what each runs, and the last call started before the last reset. */
+    const flying = new Map();
+    let since = 0;
+    /** Each call's own signal, to that call: its progress names the call it came from. */
+    const callOf = new WeakMap();
+    const listeners = new Set();
+    const show = (patch) => {
+        view = { ...view, ...patch };
+        for (const listener of listeners)
+            void (0, receipt_js_1.tell)(listener);
+    };
+    const notify = (progress, rechecking, signal) => {
+        // A call's progress shows once it started since the last reset: a call
+        // from before it changes nothing shown. Overlapping calls of one run all show.
+        const call = signal && callOf.get(signal);
+        const shows = call !== undefined && call > since;
         if (progress.type === "execution") {
             const key = `${progress.session.id}:${progress.index}`;
             const display = JSON.stringify([
@@ -369,15 +409,35 @@ function createSafeRelayrController(options) {
                 (rechecking &&
                     previous === JSON.stringify(["executed", progress.hash, undefined])))
                 return;
-            displayedExecutions.set(key, display);
+            // Only a shown row is a repeat, so a held one shows from the next call.
+            if (shows)
+                displayedExecutions.set(key, display);
         }
+        if (shows)
+            show({
+                ...(progress.session
+                    ? { session: structuredClone(progress.session) }
+                    : {}),
+                ...(progress.type === "phase"
+                    ? { phase: progress.phase }
+                    : {
+                        executions: {
+                            ...view.executions,
+                            [progress.index]: {
+                                status: progress.status,
+                                ...(progress.hash ? { hash: progress.hash } : {}),
+                                ...(progress.message ? { message: progress.message } : {}),
+                            },
+                        },
+                    }),
+            });
         // A view must not mutate frozen calls or turn a submitted payment into a
         // rejected operation: it gets a copy, and its failure is only logged.
         void (0, receipt_js_1.tell)((shown) => options.onProgress?.(structuredClone(shown)), progress);
     };
     const phase = (phase, session, signal) => {
         if (!signal?.aborted)
-            notify({ type: "phase", phase, session });
+            notify({ type: "phase", phase, session }, false, signal);
     };
     const savedPhase = (session, signal) => {
         if (session.state === "released")
@@ -755,7 +815,7 @@ function createSafeRelayrController(options) {
     async function inspect(session, signal) {
         const report = (progress, rechecking = false) => {
             if (!signal?.aborted)
-                notify(progress, rechecking);
+                notify(progress, rechecking, signal);
         };
         try {
             savedPhase(session, signal);
@@ -1170,179 +1230,240 @@ 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 >= relayr_js_1.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);
+        // Once this attempt saved "sending", every later save goes through
+        // `keep`: one refused for a lost lock leaves what it would have saved
+        // (the attempt's outcome) to be applied under a fresh lock, to the saved
+        // record only while it is still this attempt's.
+        let late;
+        const keep = async (next, onLost) => {
+            try {
+                await store.save(next);
             }
-            let verified = false;
-            let sending = false;
-            let paymentPersisted = false;
-            const requireOpenPayment = () => (0, relayr_js_1.relayrPaymentDetails)(payment, {
-                bundleUuid: session.bundleUuid,
-                destinationChainIds: session.executions.map(({ entry }) => entry.chain),
-            });
-            const beforeSend = async () => {
-                phase("payment-checking", session, signal);
-                await revalidate(session.executions, account, onStatus, true, signal);
+            catch (error) {
+                if (error instanceof locks_js_1.LockLostError)
+                    late = onLost;
+                throw error;
+            }
+        };
+        try {
+            return await funding();
+        }
+        catch (error) {
+            const settle = late;
+            if (settle)
+                await store
+                    .withLock(account, async () => {
+                    const next = settle(await load(account, sessionId));
+                    if (next)
+                        await store.save(next);
+                })
+                    // Unreconciled, the record stays as the lost lock left it.
+                    .catch(() => undefined);
+            throw error;
+        }
+        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 >= relayr_js_1.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
-                    ? (0, relayr_js_1.requireRelayrRetry)(options.clientFor, {
-                        payments: session.payments,
-                        from: account,
-                        bundleUuid: session.bundleUuid,
-                    }, { fetch: fetchRelayr })
-                    : (0, relayr_js_1.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 = () => (0, relayr_js_1.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)
-                        ? exports.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
+                        ? (0, relayr_js_1.requireRelayrRetry)(options.clientFor, {
+                            payments: session.payments,
+                            from: account,
+                            bundleUuid: session.bundleUuid,
+                        }, { fetch: fetchRelayr })
+                        : (0, relayr_js_1.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 locks_js_1.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)
+                            ? exports.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 = (0, relayr_js_1.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 = (0, relayr_js_1.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.
-                    (0, relayr_js_1.relayrPaymentAttemptOutcome)(error, { sending, paid: false }) ===
-                        "unpaid" &&
-                    session.payments.length === checked.session.payments.length) {
+                const onSent = async (payments) => {
+                    const snapshot = (0, relayr_js_1.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 = (0, relayr_js_1.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.
+                        (0, relayr_js_1.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, }) {
@@ -1361,6 +1482,10 @@ function createSafeRelayrController(options) {
         if (signal?.aborted)
             stop();
         const halted = halt.signal;
+        // Its checks' progress is the watch's own.
+        const call = signal && callOf.get(signal);
+        if (call !== undefined)
+            callOf.set(halted, call);
         try {
             const started = Date.now();
             while (true) {
@@ -1411,6 +1536,78 @@ function createSafeRelayrController(options) {
             return result("released", session);
         });
     }
-    return { prepare, check, fund, watch, exit };
+    let calls = 0;
+    /**
+     * Runs one call with its result, error and execution checks shown in the
+     * view: the latest call since the last reset shows, and so does a watch of
+     * the current run throughout, since the run waits on its polls.
+     */
+    const shown = (running, run) => async (args) => {
+        const given = args;
+        const call = ++calls;
+        const shows = () => call === calls || (running === "watch" && call > since);
+        // What still runs once this call ends: the latest call, else a watch of the current run.
+        const still = () => flying.get(calls) ??
+            ([...flying].some(([id, kind]) => kind === "watch" && id > since)
+                ? "watch"
+                : null);
+        flying.set(call, running);
+        // A signal of its own, even when the caller shares one between calls.
+        const signal = given.signal
+            ? AbortSignal.any([given.signal])
+            : new AbortController().signal;
+        callOf.set(signal, call);
+        show({ running, error: null });
+        try {
+            const result = await run({
+                ...args,
+                signal,
+                onStatus: (index, state, execution) => {
+                    if (shows())
+                        show({ checks: { ...view.checks, [index]: state } });
+                    given.onStatus?.(index, state, execution);
+                },
+                ...(running === "watch"
+                    ? {
+                        onUpdate: (result) => {
+                            if (shows())
+                                show({ result, error: null });
+                            return given.onUpdate?.(result);
+                        },
+                    }
+                    : {}),
+            });
+            flying.delete(call);
+            if (shows())
+                show({ result, error: null, running: still() });
+            return result;
+        }
+        catch (error) {
+            flying.delete(call);
+            if (shows())
+                show({ error, running: still() });
+            throw error;
+        }
+    };
+    return {
+        prepare: shown("prepare", prepare),
+        check: shown("check", check),
+        fund: shown("fund", fund),
+        watch: shown("watch", watch),
+        exit: shown("exit", exit),
+        getState: () => view,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        /** Clears the view, as a new run starts. */
+        reset() {
+            since = calls += 1;
+            displayedExecutions.clear();
+            show(SAFE_RELAYR_VIEW);
+        },
+    };
 }
 //# sourceMappingURL=safeRelayr.js.map