@bananapus/nana-sdk-core 3.5.2 → 5.0.0

package/dist/esm/review/writeRecovery.js

@@ -1,6 +1,7 @@
-import { decodeFunctionData, isAddress, keccak256, } from "viem";
-import { lookAtSafeProposal, readSafeAppExecution, readSafeTransaction, SAFE_EXEC_ABI, safeProposalFor, safeTransactionMatchesCall, } from "../safeService.js";
-import { multiSendCallsOf } from "../safe.js";
+import { ReviewLineError } from "./lineError.js";
+import { decodeFunctionData, isAddress, numberToHex, keccak256, } from "viem";
+import { lookAtSafeProposal, readSafeAppExecution, readSafeTransaction, isSafeExecTransaction, safeExecTransactionResult, SAFE_EXEC_ABI, safeProposalFor, safeTransactionMatchesCall, } from "../safeService.js";
+import { MULTI_SEND_CALL_ONLY_DEPLOYMENTS, multiSendCallsOf, readAuthorityIdentity, } from "../safe.js";
 import { TAB } from "./tabState.js";
 import { isBytes32, isHexBytes, uint256 } from "../untrusted.js";
 import { atCanonicalFinalizedBlock, } from "./relayr.js";
@@ -11,7 +12,7 @@ const TAB_SEEN = 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). */
-export class SubmittedWritePersistenceError extends Error {
+export class SubmittedWritePersistenceError extends ReviewLineError {
     constructor(record, cause) {
         super("The wallet returned a transaction identity, but recovery storage is unavailable. Keep this transaction pending.");
         this.name = "SubmittedWritePersistenceError";
@@ -23,7 +24,7 @@ function normalizedIdentity(input) {
     if (!Number.isSafeInteger(input?.chainId) ||
         input.chainId <= 0 ||
         !isAddress(input?.account, { strict: false }))
-        throw new Error("Invalid reviewed write recovery evidence.");
+        throw new ReviewLineError("Invalid reviewed write recovery evidence.");
     return {
         chainId: input.chainId,
         account: input.account.toLowerCase(),
@@ -36,7 +37,7 @@ function normalized(input) {
         !isAddress(input?.call?.to, { strict: false }) ||
         !isHexBytes(input?.call?.data) ||
         value === null)
-        throw new Error("Invalid reviewed write recovery evidence.");
+        throw new ReviewLineError("Invalid reviewed write recovery evidence.");
     return {
         ...normalizedIdentity(input),
         safe: input.safe,
@@ -80,7 +81,7 @@ function recordOf(value) {
         (record.executed !== undefined && record.executed !== true) ||
         (record.executionHash !== undefined &&
             (record.executed !== true || !isBytes32(record.executionHash))))
-        throw new Error("Invalid saved write recovery record. Keep this action pending.");
+        throw new ReviewLineError("Invalid saved write recovery record. Keep this action pending.");
     return {
         version: 1,
         id: record.id,
@@ -157,7 +158,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 ReviewLineError("Invalid write recovery namespace.");
     return value;
 }
 function namespaceScope(input) {
@@ -171,7 +172,7 @@ function scope(input) {
 function recoveryStorage(store) {
     const result = store ?? globalThis.localStorage;
     if (!result)
-        throw new Error("Write recovery storage is unavailable.");
+        throw new ReviewLineError("Write recovery storage is unavailable.");
     return result;
 }
 /** Every key `store` holds: its own `keys()`, or Web Storage's `length` and `key()`. */
@@ -363,7 +364,7 @@ export function findReviewedWrites(input, options = {}) {
     const identity = normalizedIdentity(input);
     if (!isAddress(input.to, { strict: false }) ||
         !/^0x[0-9a-fA-F]{8}$/.test(input.selector))
-        throw new Error("Invalid write hold match.");
+        throw new ReviewLineError("Invalid write hold match.");
     const to = input.to.toLowerCase();
     const selector = input.selector.toLowerCase();
     const store = recoveryStorage(options.storage);
@@ -401,7 +402,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 ReviewLineError("Invalid write recovery key.");
 }
 /**
  * Every unresolved write saved for `account` on `chainId`, with the key it
@@ -449,7 +450,7 @@ export 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 ReviewLineError("Provide a write recovery namespace.");
     return readRecovery(recoveryStorage(options.storage), namespaceScope({ ...identity, namespace }));
 }
 /**
@@ -460,12 +461,20 @@ export 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 ReviewLineError("Saved write recovery scope does not match.");
     if (store && store.getItem(releasedKey(key, record.id)) !== null)
         return null;
     return record;
@@ -669,6 +678,19 @@ export 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;
@@ -690,7 +712,7 @@ export function createBrowserWriteRecovery(input, options = {}) {
     }
     function requireLock() {
         if (!locked)
-            throw new Error("Write recovery changes require the browser lock.");
+            throw new ReviewLineError("Write recovery changes require the browser lock.");
     }
     function read() {
         const store = storage();
@@ -702,7 +724,7 @@ export 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 ReviewLineError("Write recovery storage did not retain the action.");
     }
     function clear(expected) {
         requireLock();
@@ -718,7 +740,7 @@ export 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 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.
@@ -726,13 +748,13 @@ export 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 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 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. */
@@ -760,6 +782,12 @@ export 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.
@@ -815,13 +843,13 @@ export function createBrowserWriteRecovery(input, options = {}) {
     function record(hash, expected, replace) {
         requireLock();
         if (!isBytes32(hash))
-            throw new Error("The wallet returned an invalid transaction identity.");
+            throw new 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 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
@@ -858,7 +886,7 @@ export function createBrowserWriteRecovery(input, options = {}) {
                     submittedAt: undefined,
                 }) ||
             (!replace && current.hash && current.hash !== submittedHash)) {
-            throw new Error("Write recovery changed before submission was recorded.");
+            throw new ReviewLineError("Write recovery changed before submission was recorded.");
         }
         owned = recordOf(submitted);
         if (current.hash !== submittedHash) {
@@ -892,15 +920,15 @@ export 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 ReviewLineError("The adopted write has a different recovery scope.");
             const nonce = evidence && uint256(evidence.nonce);
             const fromBlock = evidence && uint256(evidence.blockNumber);
             if (evidence && (nonce === null || fromBlock === null))
-                throw new Error("Invalid write recovery nonce evidence.");
+                throw new 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 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 {
@@ -939,6 +967,7 @@ export 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. */
@@ -971,7 +1000,7 @@ export 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 ReviewLineError("An earlier wallet write is still unresolved. Check it before trying again.");
             const mirrored = recordOf({
                 version: 1,
                 id: source.id,
@@ -1011,6 +1040,16 @@ export 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.
@@ -1074,6 +1113,10 @@ export 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(),
                 }));
             }
@@ -1087,17 +1130,29 @@ export 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
@@ -1121,6 +1176,10 @@ export function createBrowserWriteRecovery(input, options = {}) {
                     ? {
                         result: saved.result,
                         hash: saved.hash,
+                        ...(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"
@@ -1271,7 +1330,7 @@ export function createBrowserWriteRecovery(input, options = {}) {
         executed(expected, executionHash) {
             requireLock();
             if (executionHash !== undefined && !isBytes32(executionHash))
-                throw new Error("Invalid execution transaction identity.");
+                throw new ReviewLineError("Invalid execution transaction identity.");
             const store = storage();
             const { at, raw } = locate(store);
             const current = readRecovery(store, at, raw, scopeAt(at));
@@ -1279,7 +1338,7 @@ export 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 ReviewLineError("Write recovery changed. Keep the current action pending.");
             const next = recordOf({
                 ...current,
                 executed: true,
@@ -1318,7 +1377,7 @@ export 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 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);
@@ -1326,15 +1385,21 @@ export 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 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 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 ReviewLineError("Write recovery storage did not release the action.");
             const memory = unpersistedSubmissions.get(store);
             if (memory?.get(at)?.id === durable.id)
                 memory.delete(at);
@@ -1345,7 +1410,7 @@ export 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 ReviewLineError("This wallet action is already open in another tab.");
                 locked = true;
                 try {
                     return await work();
@@ -1503,7 +1568,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 = 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 } = decodeFunctionData({
@@ -1513,7 +1584,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);
@@ -1539,13 +1610,14 @@ export function heldSafeProposal(input, nonce) {
  */
 export function safeProposalIsHeldCall(proposal, input) {
     const record = normalized(input);
-    return 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) => safeTransactionMatchesCall(proposal, {
+            ...call,
+            to: to,
+            operation: 1,
+        }))
+        : safeTransactionMatchesCall(proposal, call);
 }
 /**
  * Authenticate the saved wallet identity, canonical inclusion and Safe effect.
@@ -1559,7 +1631,7 @@ export function safeProposalIsHeldCall(proposal, input) {
  */
 export 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 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];
@@ -1646,6 +1718,35 @@ export async function verifyReviewedWriteReceipt(client, saved, receipt, proof,
             throw pending();
         status = result.status;
     }
+    else if (status === "success" && 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" : numberToHex(blockNumber);
+        // Every read through the one `request` the receipt client has.
+        const identity = await 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 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 &&
@@ -1666,7 +1767,7 @@ export async function verifyReviewedWriteReceipt(client, saved, receipt, proof,
  */
 export 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 ReviewLineError("The saved Safe proposal is not proven expired. Keep this action pending.");
     if (!record.safe ||
         !record.hash ||
         (await client.getChainId()) !== record.chainId)