@bananapus/nana-sdk-core 3.5.2 → 5.0.0

package/dist/cjs/review/writeRecovery.js

@@ -16,6 +16,7 @@ exports.heldSafeProposal = heldSafeProposal;
 exports.safeProposalIsHeldCall = safeProposalIsHeldCall;
 exports.verifyReviewedWriteReceipt = verifyReviewedWriteReceipt;
 exports.verifyReviewedWriteExpiry = verifyReviewedWriteExpiry;
+const lineError_js_1 = require("./lineError.js");
 const viem_1 = require("viem");
 const safeService_js_1 = require("../safeService.js");
 const safe_js_1 = require("../safe.js");
@@ -29,7 +30,7 @@ const TAB_SEEN = tabState_js_1.TAB.seen;
 // failed. It is visible only while the exact durable reservation still exists.
 const unpersistedSubmissions = new WeakMap();
 /** The wallet returned this identity, but storing it failed. Keep it in memory and retry submitted(hash, record). */
-class SubmittedWritePersistenceError extends Error {
+class SubmittedWritePersistenceError extends lineError_js_1.ReviewLineError {
     constructor(record, cause) {
         super("The wallet returned a transaction identity, but recovery storage is unavailable. Keep this transaction pending.");
         this.name = "SubmittedWritePersistenceError";
@@ -42,7 +43,7 @@ function normalizedIdentity(input) {
     if (!Number.isSafeInteger(input?.chainId) ||
         input.chainId <= 0 ||
         !(0, viem_1.isAddress)(input?.account, { strict: false }))
-        throw new Error("Invalid reviewed write recovery evidence.");
+        throw new lineError_js_1.ReviewLineError("Invalid reviewed write recovery evidence.");
     return {
         chainId: input.chainId,
         account: input.account.toLowerCase(),
@@ -55,7 +56,7 @@ function normalized(input) {
         !(0, viem_1.isAddress)(input?.call?.to, { strict: false }) ||
         !(0, untrusted_js_1.isHexBytes)(input?.call?.data) ||
         value === null)
-        throw new Error("Invalid reviewed write recovery evidence.");
+        throw new lineError_js_1.ReviewLineError("Invalid reviewed write recovery evidence.");
     return {
         ...normalizedIdentity(input),
         safe: input.safe,
@@ -99,7 +100,7 @@ function recordOf(value) {
         (record.executed !== undefined && record.executed !== true) ||
         (record.executionHash !== undefined &&
             (record.executed !== true || !(0, untrusted_js_1.isBytes32)(record.executionHash))))
-        throw new Error("Invalid saved write recovery record. Keep this action pending.");
+        throw new lineError_js_1.ReviewLineError("Invalid saved write recovery record. Keep this action pending.");
     return {
         version: 1,
         id: record.id,
@@ -174,7 +175,7 @@ function namespaceOf(value) {
         return undefined;
     if (typeof value !== "string" ||
         !/^[a-z0-9][a-z0-9:._/-]{0,127}$/.test(value))
-        throw new Error("Invalid write recovery namespace.");
+        throw new lineError_js_1.ReviewLineError("Invalid write recovery namespace.");
     return value;
 }
 function namespaceScope(input) {
@@ -188,7 +189,7 @@ function scope(input) {
 function recoveryStorage(store) {
     const result = store ?? globalThis.localStorage;
     if (!result)
-        throw new Error("Write recovery storage is unavailable.");
+        throw new lineError_js_1.ReviewLineError("Write recovery storage is unavailable.");
     return result;
 }
 /** Every key `store` holds: its own `keys()`, or Web Storage's `length` and `key()`. */
@@ -380,7 +381,7 @@ function findReviewedWrites(input, options = {}) {
     const identity = normalizedIdentity(input);
     if (!(0, viem_1.isAddress)(input.to, { strict: false }) ||
         !/^0x[0-9a-fA-F]{8}$/.test(input.selector))
-        throw new Error("Invalid write hold match.");
+        throw new lineError_js_1.ReviewLineError("Invalid write hold match.");
     const to = input.to.toLowerCase();
     const selector = input.selector.toLowerCase();
     const store = recoveryStorage(options.storage);
@@ -418,7 +419,7 @@ function foundAt(input, at) {
             (at.startsWith(prefix) &&
                 /^\d+:0x[0-9a-f]{64}$/.test(at.slice(prefix.length)))))
         return at;
-    throw new Error("Invalid write recovery key.");
+    throw new lineError_js_1.ReviewLineError("Invalid write recovery key.");
 }
 /**
  * Every unresolved write saved for `account` on `chainId`, with the key it
@@ -466,7 +467,7 @@ function readBrowserWriteRecovery(input, options = {}) {
     const identity = normalizedIdentity(input);
     const namespace = namespaceOf(input?.namespace);
     if (namespace === undefined)
-        throw new Error("Provide a write recovery namespace.");
+        throw new lineError_js_1.ReviewLineError("Provide a write recovery namespace.");
     return readRecovery(recoveryStorage(options.storage), namespaceScope({ ...identity, namespace }));
 }
 /**
@@ -477,12 +478,20 @@ function readBrowserWriteRecovery(input, options = {}) {
 function releasedKey(key, id) {
     return `${key}:released:${id}`;
 }
+/**
+ * The key that marks the record `id` saved at `key` as ended by the user's
+ * exit or as never sent, never by a settlement's cleanup: only it lets a
+ * saved sequence send that step again.
+ */
+function exitedKey(key, id) {
+    return `${key}:exited:${id}`;
+}
 function readStored(raw, key, scopeOf = scope, store) {
     if (raw === null)
         return null;
     const record = recordOf(JSON.parse(raw));
     if (scopeOf(record) !== key)
-        throw new Error("Saved write recovery scope does not match.");
+        throw new lineError_js_1.ReviewLineError("Saved write recovery scope does not match.");
     if (store && store.getItem(releasedKey(key, record.id)) !== null)
         return null;
     return record;
@@ -686,6 +695,19 @@ function createBrowserWriteRecovery(input, options = {}) {
     function scopeAt(at) {
         return at === key ? keyOf : legacyScope;
     }
+    /**
+     * Set `flag` on the saved settlement with this (lowercase) hash: false when
+     * it was already set, true otherwise (another settlement stays as it is).
+     */
+    function flagSettled(store, hash, flag) {
+        const saved = JSON.parse(store.getItem(settledKey) ?? "null");
+        if (saved?.hash !== hash)
+            return true;
+        if (saved[flag] === true)
+            return false;
+        store.setItem(settledKey, JSON.stringify({ ...saved, [flag]: true }));
+        return true;
+    }
     function storage() {
         const store = recoveryStorage(options.storage);
         lastStorage = store;
@@ -707,7 +729,7 @@ function createBrowserWriteRecovery(input, options = {}) {
     }
     function requireLock() {
         if (!locked)
-            throw new Error("Write recovery changes require the browser lock.");
+            throw new lineError_js_1.ReviewLineError("Write recovery changes require the browser lock.");
     }
     function read() {
         const store = storage();
@@ -719,7 +741,7 @@ function createBrowserWriteRecovery(input, options = {}) {
         const store = storage();
         store.setItem(at, raw);
         if (store.getItem(at) !== raw)
-            throw new Error("Write recovery storage did not retain the action.");
+            throw new lineError_js_1.ReviewLineError("Write recovery storage did not retain the action.");
     }
     function clear(expected) {
         requireLock();
@@ -735,7 +757,7 @@ function createBrowserWriteRecovery(input, options = {}) {
         if (!current)
             return;
         if (JSON.stringify(current) !== JSON.stringify(recordOf(expected))) {
-            throw new Error("Write recovery changed. Keep the current action pending.");
+            throw new lineError_js_1.ReviewLineError("Write recovery changed. Keep the current action pending.");
         }
         // The last record of an attempt goes only once its generation is the
         // committed latest marker; otherwise it stays, released, and carries it.
@@ -743,13 +765,13 @@ function createBrowserWriteRecovery(input, options = {}) {
             const marker = releasedKey(at, current.id);
             store.setItem(marker, "1");
             if (store.getItem(marker) !== "1")
-                throw new Error("Write recovery storage did not clear the action.");
+                throw new lineError_js_1.ReviewLineError("Write recovery storage did not clear the action.");
             unpersistedSubmissions.get(store)?.delete(at);
             return;
         }
         store.removeItem(at);
         if (store.getItem(at) !== null)
-            throw new Error("Write recovery storage did not clear the action.");
+            throw new lineError_js_1.ReviewLineError("Write recovery storage did not clear the action.");
         unpersistedSubmissions.get(store)?.delete(at);
     }
     /** Add `fields` to exactly `expected`, a hashed record `when` allows; extra evidence only. */
@@ -777,6 +799,12 @@ function createBrowserWriteRecovery(input, options = {}) {
         const current = read();
         if (current?.id === owned.id && current.hash)
             return;
+        try {
+            storage().setItem(exitedKey(locate(storage()).at, owned.id), "1");
+        }
+        catch {
+            /* Unsaved, a sequence resumed over it asks for the user's check. */
+        }
         // Removing the record must not uncover a settlement of an earlier
         // attempt: unless this reservation is the verified latest, it stays as
         // released instead, which still invalidates that settlement.
@@ -832,13 +860,13 @@ function createBrowserWriteRecovery(input, options = {}) {
     function record(hash, expected, replace) {
         requireLock();
         if (!(0, untrusted_js_1.isBytes32)(hash))
-            throw new Error("The wallet returned an invalid transaction identity.");
+            throw new lineError_js_1.ReviewLineError("The wallet returned an invalid transaction identity.");
         const previous = expected && recordOf(expected);
         const submittedHash = hash.toLowerCase();
         if (!previous ||
             keyOf(previous) !== key ||
             (!replace && previous.hash && previous.hash !== submittedHash)) {
-            throw new Error("Write recovery changed before submission was recorded.");
+            throw new lineError_js_1.ReviewLineError("Write recovery changed before submission was recorded.");
         }
         // A hash the wallet returns now starts its clock; a speed-up found at its nonce keeps it.
         const submittedAt = replace || previous.hash === submittedHash
@@ -875,7 +903,7 @@ function createBrowserWriteRecovery(input, options = {}) {
                     submittedAt: undefined,
                 }) ||
             (!replace && current.hash && current.hash !== submittedHash)) {
-            throw new Error("Write recovery changed before submission was recorded.");
+            throw new lineError_js_1.ReviewLineError("Write recovery changed before submission was recorded.");
         }
         owned = recordOf(submitted);
         if (current.hash !== submittedHash) {
@@ -909,15 +937,15 @@ function createBrowserWriteRecovery(input, options = {}) {
                 ? normalized({ ...reviewed, call: actualCall })
                 : reviewed;
             if (legacyScope(actual) !== legacyScope(reviewed))
-                throw new Error("The adopted write has a different recovery scope.");
+                throw new lineError_js_1.ReviewLineError("The adopted write has a different recovery scope.");
             const nonce = evidence && (0, untrusted_js_1.uint256)(evidence.nonce);
             const fromBlock = evidence && (0, untrusted_js_1.uint256)(evidence.blockNumber);
             if (evidence && (nonce === null || fromBlock === null))
-                throw new Error("Invalid write recovery nonce evidence.");
+                throw new lineError_js_1.ReviewLineError("Invalid write recovery nonce evidence.");
             const store = storage();
             const { at, raw } = locate(store);
             if (readRecovery(store, at, raw, scopeAt(at)))
-                throw new Error("An earlier wallet write is still unresolved. Check it before trying again.");
+                throw new lineError_js_1.ReviewLineError("An earlier wallet write is still unresolved. Check it before trying again.");
             // The record this one replaces, if the user released it: its marker goes too.
             let replaced;
             try {
@@ -956,6 +984,7 @@ function createBrowserWriteRecovery(input, options = {}) {
             if (typeof replaced === "string" && replaced !== record.id)
                 try {
                     store.removeItem(releasedKey(key, replaced));
+                    store.removeItem(exitedKey(key, replaced));
                 }
                 catch {
                     /* A leftover marker names only the old record. */
@@ -988,7 +1017,7 @@ function createBrowserWriteRecovery(input, options = {}) {
             requireLock();
             const current = read();
             if (current && current.mirrorOf !== of)
-                throw new Error("An earlier wallet write is still unresolved. Check it before trying again.");
+                throw new lineError_js_1.ReviewLineError("An earlier wallet write is still unresolved. Check it before trying again.");
             const mirrored = recordOf({
                 version: 1,
                 id: source.id,
@@ -1028,6 +1057,16 @@ function createBrowserWriteRecovery(input, options = {}) {
                 return undefined;
             }
         },
+        /** Whether the record `id` ended by the user's exit, or because nothing was sent. */
+        released(id) {
+            try {
+                const store = storage();
+                return store.getItem(exitedKey(locate(store).at, id)) !== null;
+            }
+            catch {
+                return false;
+            }
+        },
         /**
          * The call's latest reservation id: the record saved at the key (held,
          * or released by its exit), or else the saved latest marker.
@@ -1091,6 +1130,10 @@ function createBrowserWriteRecovery(input, options = {}) {
                     id: expected.id,
                     result: settlement.result,
                     hash: settlement.hash.toLowerCase(),
+                    ...(settlement.blockHash
+                        ? { blockHash: settlement.blockHash.toLowerCase() }
+                        : {}),
+                    ...(settlement.safe ? { safe: true } : {}),
                     at: Date.now(),
                 }));
             }
@@ -1104,17 +1147,29 @@ function createBrowserWriteRecovery(input, options = {}) {
          */
         acknowledgeSettled(settled) {
             requireLock();
-            const store = storage();
             try {
-                const raw = store.getItem(settledKey);
-                const saved = JSON.parse(raw ?? "null");
-                if (saved?.hash === settled.hash.toLowerCase())
-                    store.setItem(settledKey, JSON.stringify({ ...saved, acknowledged: true }));
+                flagSettled(storage(), settled.hash.toLowerCase(), "acknowledged");
             }
             catch {
                 /* An unreadable settlement names none; a refused write keeps it unacknowledged. */
             }
         },
+        /**
+         * Claim the one `onConfirmed` notice of the saved settlement `settled`
+         * names (its hash): true for the first claim in any tab or run, false
+         * after. A settlement no longer saved there can't be marked, so every
+         * claim of it is true: a repeated notice over a lost one.
+         */
+        claimConfirmedSettled(settled) {
+            requireLock();
+            try {
+                return flagSettled(storage(), settled.hash.toLowerCase(), "confirmed");
+            }
+            catch {
+                // Storage unavailable: told rather than lost.
+                return true;
+            }
+        },
         /**
          * How the call's last write ended, if {@link markSettled} saved it for
          * the call's latest reservation; a settlement of an earlier one reads as
@@ -1138,6 +1193,10 @@ function createBrowserWriteRecovery(input, options = {}) {
                     ? {
                         result: saved.result,
                         hash: saved.hash,
+                        ...((0, untrusted_js_1.isBytes32)(saved.blockHash)
+                            ? { blockHash: saved.blockHash }
+                            : {}),
+                        ...(saved.safe === true ? { safe: true } : {}),
                         // Saved before 2.39 (a latest marker with no time): the user
                         // saw it then, so it reads as acknowledged.
                         ...(saved.acknowledged === true || typeof latest.at !== "number"
@@ -1288,7 +1347,7 @@ function createBrowserWriteRecovery(input, options = {}) {
         executed(expected, executionHash) {
             requireLock();
             if (executionHash !== undefined && !(0, untrusted_js_1.isBytes32)(executionHash))
-                throw new Error("Invalid execution transaction identity.");
+                throw new lineError_js_1.ReviewLineError("Invalid execution transaction identity.");
             const store = storage();
             const { at, raw } = locate(store);
             const current = readRecovery(store, at, raw, scopeAt(at));
@@ -1296,7 +1355,7 @@ function createBrowserWriteRecovery(input, options = {}) {
             if (!current?.hash ||
                 current.id !== wanted.id ||
                 current.hash !== wanted.hash)
-                throw new Error("Write recovery changed. Keep the current action pending.");
+                throw new lineError_js_1.ReviewLineError("Write recovery changed. Keep the current action pending.");
             const next = recordOf({
                 ...current,
                 executed: true,
@@ -1335,7 +1394,7 @@ function createBrowserWriteRecovery(input, options = {}) {
          */
         abandon(expected, acknowledgement) {
             if (acknowledgement?.checkedWallet !== true)
-                throw new Error("Release a held write only after the user confirms they checked their wallet.");
+                throw new lineError_js_1.ReviewLineError("Release a held write only after the user confirms they checked their wallet.");
             const wanted = JSON.stringify(recordOf(expected));
             const store = storage();
             const { at, raw } = locate(store);
@@ -1343,15 +1402,21 @@ function createBrowserWriteRecovery(input, options = {}) {
             if (!durable)
                 return;
             if (durable.executed)
-                throw new Error("This write ran onchain. Keep it held until its result is known.");
+                throw new lineError_js_1.ReviewLineError("This write ran onchain. Keep it held until its result is known.");
             const shown = readRecovery(store, at, raw, scopeAt(at));
             if (JSON.stringify(durable) !== wanted &&
                 JSON.stringify(shown) !== wanted)
-                throw new Error("Write recovery changed. Keep the current action pending.");
+                throw new lineError_js_1.ReviewLineError("Write recovery changed. Keep the current action pending.");
             const marker = releasedKey(at, durable.id);
+            try {
+                store.setItem(exitedKey(at, durable.id), "1");
+            }
+            catch {
+                /* Unsaved, a sequence resumed over it asks for the user's check. */
+            }
             store.setItem(marker, "1");
             if (store.getItem(marker) !== "1")
-                throw new Error("Write recovery storage did not release the action.");
+                throw new lineError_js_1.ReviewLineError("Write recovery storage did not release the action.");
             const memory = unpersistedSubmissions.get(store);
             if (memory?.get(at)?.id === durable.id)
                 memory.delete(at);
@@ -1362,7 +1427,7 @@ function createBrowserWriteRecovery(input, options = {}) {
             const locks = options.locks ?? browserLocks();
             return locks.request(key, { mode: "exclusive", ...(!wait && { ifAvailable: true }) }, async (lock) => {
                 if (!lock)
-                    throw new Error("This wallet action is already open in another tab.");
+                    throw new lineError_js_1.ReviewLineError("This wallet action is already open in another tab.");
                 locked = true;
                 try {
                     return await work();
@@ -1520,7 +1585,13 @@ function heldBatch(record) {
         : null;
     return inner && inner.map((call) => normalized({ ...record, call }).call);
 }
-/** Whether `transaction` is the Safe's execTransaction of exactly the held batch: its MultiSend target, calldata, zero value and DELEGATECALL. */
+/**
+ * The MultiSend targets a held batch may run through: a Safe app folds the
+ * same calls into its own version's MultiSendCallOnly, so any recognized
+ * deployment carries exactly the held calldata.
+ */
+const BATCH_TARGETS = safe_js_1.MULTI_SEND_CALL_ONLY_DEPLOYMENTS.map((to) => to.toLowerCase());
+/** Whether `transaction` is the Safe's execTransaction of exactly the held batch: a recognized MultiSendCallOnly, its calldata, zero value and DELEGATECALL. */
 function runsHeldBatch(transaction, record) {
     try {
         const { functionName, args } = (0, viem_1.decodeFunctionData)({
@@ -1530,7 +1601,7 @@ function runsHeldBatch(transaction, record) {
         if (functionName !== "execTransaction")
             return false;
         const [to, value, data, operation] = args;
-        return (to.toLowerCase() === record.call.to &&
+        return (BATCH_TARGETS.includes(to.toLowerCase()) &&
             value === 0n &&
             data.toLowerCase() === record.call.data &&
             operation === 1);
@@ -1556,13 +1627,14 @@ function heldSafeProposal(input, nonce) {
  */
 function safeProposalIsHeldCall(proposal, input) {
     const record = normalized(input);
-    return (0, safeService_js_1.safeTransactionMatchesCall)(proposal, {
-        ...record.call,
-        value: BigInt(record.call.value),
-        ...(heldBatch({ ...record, version: 1, id: "" })
-            ? { operation: 1 }
-            : {}),
-    });
+    const call = { ...record.call, value: BigInt(record.call.value) };
+    return heldBatch({ ...record, version: 1, id: "" })
+        ? BATCH_TARGETS.some((to) => (0, safeService_js_1.safeTransactionMatchesCall)(proposal, {
+            ...call,
+            to: to,
+            operation: 1,
+        }))
+        : (0, safeService_js_1.safeTransactionMatchesCall)(proposal, call);
 }
 /**
  * Authenticate the saved wallet identity, canonical inclusion and Safe effect.
@@ -1576,7 +1648,7 @@ function safeProposalIsHeldCall(proposal, input) {
  */
 async function verifyReviewedWriteReceipt(client, saved, receipt, proof, { finality = true } = {}) {
     const record = recordOf(saved);
-    const pending = () => new Error("The saved wallet write is not yet proven. Keep this action pending.");
+    const pending = () => new lineError_js_1.ReviewLineError("The saved wallet write is not yet proven. Keep this action pending.");
     // A batch hold's call is its MultiSend: its proof is the calls it encodes.
     const batch = heldBatch(record);
     let calls = batch ?? [record.call];
@@ -1663,6 +1735,35 @@ async function verifyReviewedWriteReceipt(client, saved, receipt, proof, { final
             throw pending();
         status = result.status;
     }
+    else if (status === "success" && (0, safeService_js_1.isSafeExecTransaction)(record.call.data)) {
+        // A Safe's execTransaction succeeds only with the Safe's own
+        // ExecutionSuccess for its exact hash: an ExecutionFailure, or no event
+        // for it, is a failure whatever the receipt's status. A call that only
+        // shares the selector, to anything but a Safe, is decided as any other.
+        if (!client.request)
+            throw pending();
+        const { request } = client;
+        const at = (blockNumber) => blockNumber === undefined ? "latest" : (0, viem_1.numberToHex)(blockNumber);
+        // Every read through the one `request` the receipt client has.
+        const identity = await (0, safe_js_1.readAuthorityIdentity)({
+            request,
+            getCode: ({ address, blockNumber }) => request({
+                method: "eth_getCode",
+                params: [address, at(blockNumber)],
+            }),
+            getStorageAt: ({ address, slot, blockNumber }) => request({
+                method: "eth_getStorageAt",
+                params: [address, slot, at(blockNumber)],
+            }),
+        }, record.call.to, { blockNumber: canonical.blockNumber });
+        if (!identity)
+            throw pending();
+        if (identity.kind === "safe") {
+            const execution = await (0, safeService_js_1.safeExecTransactionResult)({ request: client.request }, record.chainId, record.call.to, record.call.data, canonical);
+            if (execution?.status !== "success")
+                status = "failed";
+        }
+    }
     const isCanonical = async () => {
         const block = await client.getBlock({ blockNumber: canonical.blockNumber });
         return (block.number === canonical.blockNumber &&
@@ -1683,7 +1784,7 @@ async function verifyReviewedWriteReceipt(client, saved, receipt, proof, { final
  */
 async function verifyReviewedWriteExpiry(client, saved, service) {
     const record = recordOf(saved);
-    const pending = () => new Error("The saved Safe proposal is not proven expired. Keep this action pending.");
+    const pending = () => new lineError_js_1.ReviewLineError("The saved Safe proposal is not proven expired. Keep this action pending.");
     if (!record.safe ||
         !record.hash ||
         (await client.getChainId()) !== record.chainId)