@owney/sdk 0.7.27-beta.2 → 0.7.27-beta.3

package/dist/index.cjs

@@ -1,8 +1,18 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,153 +25,76 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AgentChainIncompatibleError: () => AgentChainIncompatibleError,
-  AgentNotFoundError: () => AgentNotFoundError,
-  InvalidHistoryCursorError: () => InvalidHistoryCursorError,
-  NotConnectedError: () => NotConnectedError,
-  OwneyError: () => OwneyError,
-  OwneySDK: () => OwneySDK,
-  YieldseekerAgent: () => YieldseekerAgent,
-  clearWithdrawSwap: () => clearWithdrawSwap,
-  createOwneySIWX: () => createOwneySIWX,
-  listPendingDeposits: () => listPendingDeposits,
-  listPendingSwaps: () => listOrders,
-  listWithdrawSwaps: () => listWithdrawSwaps,
-  saveWithdrawSwap: () => saveWithdrawSwap,
-  setOwneyDebug: () => setOwneyDebug,
-  subscribeWithdrawSwaps: () => subscribeWithdrawSwaps,
-  updateWithdrawSwap: () => updateWithdrawSwap
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/errors.ts
-var OwneyError = class extends Error {
-  code;
-  details;
-  agentId;
-  constructor(code, message, details, agentId) {
-    const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
-    super(`${prefix} ${message}`);
-    this.name = "OwneyError";
-    this.code = code;
-    this.details = details;
-    this.agentId = agentId;
-  }
-};
-var AgentNotFoundError = class extends OwneyError {
-  constructor(agentId, available) {
-    super(
-      "AGENT_NOT_FOUND",
-      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
-      { agentId, available },
-      agentId
-    );
-    this.name = "AgentNotFoundError";
-  }
-};
-var NotConnectedError = class extends OwneyError {
-  constructor() {
-    super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
-    this.name = "NotConnectedError";
-  }
-};
-var AgentChainIncompatibleError = class extends OwneyError {
-  incompatibleAgents;
-  connectedChainId;
-  constructor(incompatibleAgents, connectedChainId) {
-    const details = incompatibleAgents.map(
-      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
-    ).join("; ");
-    super(
-      "AGENT_CHAIN_INCOMPATIBLE",
-      `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
-      { incompatibleAgents, connectedChainId }
-    );
-    this.name = "AgentChainIncompatibleError";
-    this.incompatibleAgents = incompatibleAgents;
-    this.connectedChainId = connectedChainId;
-  }
-};
-
-// src/lib/swap/swap.observation.ts
-var active = /* @__PURE__ */ new Set();
-var isOrderObserved = (key2) => active.has(key2);
-async function observeOrder(key2, run) {
-  const busy = () => new OwneyError(
-    "SWAP_REQUEST_FAILED",
-    "This order is already being observed.",
-    { orderHash: key2, watchActive: true, settlementUnconfirmed: true }
-  );
-  if (active.has(key2)) throw busy();
-  active.add(key2);
-  try {
-    if (typeof navigator !== "undefined" && navigator.locks)
-      return await navigator.locks.request(`owney.swap.observe:${key2}`, { ifAvailable: true }, (lock) => {
-        if (!lock) throw busy();
-        return run();
-      });
-    return await run();
-  } finally {
-    active.delete(key2);
-  }
-}
-
-// src/lib/swap/swap.deadline.ts
-async function bounded(work, timeoutMs, error) {
-  if (timeoutMs <= 0) throw error();
-  let timer;
-  try {
-    return await Promise.race([
-      Promise.resolve().then(work),
-      new Promise((_, reject) => {
-        timer = setTimeout(() => reject(error()), timeoutMs);
-      })
-    ]);
-  } finally {
-    clearTimeout(timer);
+var OwneyError, AgentNotFoundError, NotConnectedError, AgentChainIncompatibleError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    OwneyError = class extends Error {
+      code;
+      details;
+      agentId;
+      constructor(code, message, details, agentId) {
+        const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
+        super(`${prefix} ${message}`);
+        this.name = "OwneyError";
+        this.code = code;
+        this.details = details;
+        this.agentId = agentId;
+      }
+    };
+    AgentNotFoundError = class extends OwneyError {
+      constructor(agentId, available) {
+        super(
+          "AGENT_NOT_FOUND",
+          `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
+          { agentId, available },
+          agentId
+        );
+        this.name = "AgentNotFoundError";
+      }
+    };
+    NotConnectedError = class extends OwneyError {
+      constructor() {
+        super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
+        this.name = "NotConnectedError";
+      }
+    };
+    AgentChainIncompatibleError = class extends OwneyError {
+      incompatibleAgents;
+      connectedChainId;
+      constructor(incompatibleAgents, connectedChainId) {
+        const details = incompatibleAgents.map(
+          ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
+        ).join("; ");
+        super(
+          "AGENT_CHAIN_INCOMPATIBLE",
+          `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
+          { incompatibleAgents, connectedChainId }
+        );
+        this.name = "AgentChainIncompatibleError";
+        this.incompatibleAgents = incompatibleAgents;
+        this.connectedChainId = connectedChainId;
+      }
+    };
   }
-}
-async function mapConcurrent(items, run, concurrency = 3) {
-  const results = new Array(items.length);
-  let next = 0;
-  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, async () => {
-    for (; ; ) {
-      const index = next++;
-      if (index >= items.length) return;
-      results[index] = await run(items[index]);
-    }
-  }));
-  return results;
-}
+});
 
 // src/lib/permit2-batch.ts
-var import_viem = require("viem");
-var BATCH_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-var BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var ARBITRUM_USDC_ADDRESS = "0xaf88d065e77c8cc2239327c5edb3a432268e5831";
 function supportsSponsoredErc2612(chainId, token) {
   const expected = chainId === 8453 ? BASE_USDC_ADDRESS : chainId === 42161 ? ARBITRUM_USDC_ADDRESS : void 0;
   return expected !== void 0 && token.toLowerCase() === expected.toLowerCase();
 }
-var ERC2612_PERMIT_TYPES = {
-  Permit: [
-    { name: "owner", type: "address" },
-    { name: "spender", type: "address" },
-    { name: "value", type: "uint256" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" }
-  ]
-};
-var ERC2612_READ_ABI = (0, import_viem.parseAbi)([
-  "function name() view returns (string)",
-  "function version() view returns (string)",
-  "function nonces(address owner) view returns (uint256)"
-]);
 function erc2612TypedData(input) {
   return {
     domain: {
@@ -181,27 +114,6 @@ function erc2612TypedData(input) {
     }
   };
 }
-var PERMIT_BATCH_TYPES = {
-  PermitBatchWitnessTransferFrom: [
-    { name: "permitted", type: "TokenPermissions[]" },
-    { name: "spender", type: "address" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" },
-    { name: "witness", type: "Deposit" }
-  ],
-  Deposit: [{ name: "recipients", type: "address[]" }],
-  TokenPermissions: [
-    { name: "token", type: "address" },
-    { name: "amount", type: "uint256" }
-  ]
-};
-var PERMIT2_BATCH_ABI = (0, import_viem.parseAbi)([
-  "struct TokenPermissions { address token; uint256 amount; }",
-  "struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }",
-  "struct SignatureTransferDetails { address to; uint256 requestedAmount; }",
-  "function permitWitnessTransferFrom(PermitBatchTransferFrom permit,SignatureTransferDetails[] transferDetails,address owner,bytes32 witness,string witnessTypeString,bytes signature)",
-  "function nonceBitmap(address owner,uint256 wordPos) view returns (uint256)"
-]);
 function batchPermit(b) {
   return {
     permitted: b.transfers.map((t) => ({
@@ -228,7 +140,6 @@ function batchTypedData(b, spender) {
     }
   };
 }
-var BATCH_WITNESS_TYPE = "Deposit witness)Deposit(address[] recipients)TokenPermissions(address token,uint256 amount)";
 function batchWitness(b) {
   return (0, import_viem.hashStruct)({
     types: PERMIT_BATCH_TYPES,
@@ -246,9 +157,451 @@ function batchArgs(b) {
     b.signature
   ];
 }
+var import_viem, BATCH_PERMIT2_ADDRESS, BASE_USDC_ADDRESS, ARBITRUM_USDC_ADDRESS, ERC2612_PERMIT_TYPES, ERC2612_READ_ABI, PERMIT_BATCH_TYPES, PERMIT2_BATCH_ABI, BATCH_WITNESS_TYPE;
+var init_permit2_batch = __esm({
+  "src/lib/permit2-batch.ts"() {
+    "use strict";
+    import_viem = require("viem");
+    BATCH_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+    BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+    ARBITRUM_USDC_ADDRESS = "0xaf88d065e77c8cc2239327c5edb3a432268e5831";
+    ERC2612_PERMIT_TYPES = {
+      Permit: [
+        { name: "owner", type: "address" },
+        { name: "spender", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ]
+    };
+    ERC2612_READ_ABI = (0, import_viem.parseAbi)([
+      "function name() view returns (string)",
+      "function version() view returns (string)",
+      "function nonces(address owner) view returns (uint256)"
+    ]);
+    PERMIT_BATCH_TYPES = {
+      PermitBatchWitnessTransferFrom: [
+        { name: "permitted", type: "TokenPermissions[]" },
+        { name: "spender", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+        { name: "witness", type: "Deposit" }
+      ],
+      Deposit: [{ name: "recipients", type: "address[]" }],
+      TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" }
+      ]
+    };
+    PERMIT2_BATCH_ABI = (0, import_viem.parseAbi)([
+      "struct TokenPermissions { address token; uint256 amount; }",
+      "struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }",
+      "struct SignatureTransferDetails { address to; uint256 requestedAmount; }",
+      "function permitWitnessTransferFrom(PermitBatchTransferFrom permit,SignatureTransferDetails[] transferDetails,address owner,bytes32 witness,string witnessTypeString,bytes signature)",
+      "function nonceBitmap(address owner,uint256 wordPos) view returns (uint256)"
+    ]);
+    BATCH_WITNESS_TYPE = "Deposit witness)Deposit(address[] recipients)TokenPermissions(address token,uint256 amount)";
+  }
+});
+
+// src/lib/token-batch-family.ts
+var token_batch_family_exports = {};
+__export(token_batch_family_exports, {
+  finishTokenBatchFamily: () => finishTokenBatchFamily,
+  loadTokenBatchFamily: () => loadTokenBatchFamily,
+  saveTokenBatchAttempt: () => saveTokenBatchAttempt,
+  tokenBatchAuthorizationId: () => tokenBatchAuthorizationId,
+  tokenBatchCall: () => tokenBatchCall,
+  tokenBatchClear: () => tokenBatchClear,
+  tokenBatchKey: () => tokenBatchKey,
+  tokenBatchRead: () => tokenBatchRead,
+  tokenBatchStoredBody: () => tokenBatchStoredBody,
+  tokenBatchWrite: () => tokenBatchWrite,
+  validateTokenBatchAttempt: () => validateTokenBatchAttempt
+});
+function tokenBatchRead(key2) {
+  const raw2 = typeof window === "undefined" ? memory.get(key2) : window.localStorage.getItem(key2) ?? void 0;
+  return raw2 && settled.get(key2) === raw2 ? void 0 : raw2;
+}
+function tokenBatchWrite(key2, value) {
+  if (typeof window === "undefined") memory.set(key2, value);
+  else window.localStorage.setItem(key2, value);
+  settled.delete(key2);
+  if (tokenBatchRead(key2) !== value)
+    throw pending("Deposit recovery data could not be saved.");
+}
+function tokenBatchClear(key2, expected) {
+  if (tokenBatchRead(key2) !== expected) return;
+  try {
+    if (typeof window === "undefined") memory.delete(key2);
+    else window.localStorage.removeItem(key2);
+  } catch {
+    settled.set(key2, expected);
+  }
+}
+function keys() {
+  if (typeof window === "undefined") return [...memory.keys()];
+  const storage8 = window.localStorage;
+  return Array.from(
+    { length: storage8.length },
+    (_, i) => storage8.key(i)
+  ).filter((key2) => key2 !== null);
+}
+function pending(message = "The saved deposit could not be verified. Its existing transactions remain pending.") {
+  return new OwneyError("DEPOSIT_IN_PROGRESS", message, {
+    sponsorPending: true,
+    notSubmitted: false,
+    safeToFallback: false
+  });
+}
+function tokenBatchCall(body, phase) {
+  if (phase === "deposit")
+    return {
+      to: BATCH_PERMIT2_ADDRESS,
+      data: (0, import_viem2.encodeFunctionData)({
+        abi: PERMIT2_BATCH_ABI,
+        functionName: "permitWitnessTransferFrom",
+        args: batchArgs(body)
+      })
+    };
+  const p = body.erc2612Permit;
+  let v = Number((0, import_viem2.sliceHex)(p.signature, 64));
+  if (v < 27) v += 27;
+  return {
+    to: body.token,
+    data: (0, import_viem2.encodeFunctionData)({
+      abi: approvalAbi,
+      functionName: "permit",
+      args: [
+        body.from,
+        BATCH_PERMIT2_ADDRESS,
+        BigInt(p.value),
+        BigInt(p.deadline),
+        v,
+        (0, import_viem2.sliceHex)(p.signature, 0, 32),
+        (0, import_viem2.sliceHex)(p.signature, 32, 64)
+      ]
+    })
+  };
+}
+async function validateBody(scope, body, relayer) {
+  if (!body || body.chainId !== scope.chainId || !(0, import_viem2.isAddressEqual)(body.from, scope.owner) || !(0, import_viem2.isAddressEqual)(body.token, scope.token) || !uint(body.nonce) || !uint(body.deadline) || BigInt(body.deadline) === 0n || !Array.isArray(body.transfers) || !body.transfers.length || body.transfers.length > 16 || body.transfers.some(
+    (t) => !(0, import_viem2.isAddress)(t.to) || !uint(t.amount) || BigInt(t.amount) === 0n
+  ) || new Set(body.transfers.map((t) => t.to.toLowerCase())).size !== body.transfers.length)
+    throw pending();
+  if (!(0, import_viem2.isAddressEqual)(
+    await (0, import_viem2.recoverTypedDataAddress)({
+      ...batchTypedData(body, relayer),
+      signature: body.signature
+    }),
+    body.from
+  ))
+    throw pending();
+  const p = body.erc2612Permit;
+  if (p) {
+    if (!supportsSponsoredErc2612(body.chainId, body.token) || !uint(p.nonce) || !uint(p.deadline) || !uint(p.value) || BigInt(p.value) !== (1n << 256n) - 1n || p.deadline !== body.deadline || typeof p.tokenName !== "string" || typeof p.tokenVersion !== "string")
+      throw pending();
+    if (!(0, import_viem2.isAddressEqual)(
+      await (0, import_viem2.recoverTypedDataAddress)({
+        ...erc2612TypedData({
+          chainId: body.chainId,
+          token: body.token,
+          owner: body.from,
+          permit: p
+        }),
+        signature: p.signature
+      }),
+      body.from
+    ))
+      throw pending();
+  }
+}
+async function validateTokenBatchAttempt(scope, body, attempt, expectedRelayer) {
+  if (!attempt || !["approval", "deposit"].includes(attempt.phase) || !hashPattern.test(attempt.hash) || !uint(attempt.nonce) || !Number.isFinite(attempt.preparedAt) || typeof attempt.submissionAttempted !== "boolean" || attempt.predecessorHash !== void 0 && !hashPattern.test(attempt.predecessorHash))
+    throw pending();
+  if (typeof attempt.serializedTransaction !== "string" || !/^0x(?:[\da-f]{2}){1,32768}$/i.test(attempt.serializedTransaction))
+    throw pending();
+  const serialized = attempt.serializedTransaction;
+  if (!same((0, import_viem2.keccak256)(serialized), attempt.hash)) throw pending();
+  const tx = (0, import_viem2.parseTransaction)(serialized), relayer = await (0, import_viem2.recoverTransactionAddress)({
+    serializedTransaction: serialized
+  });
+  if (expectedRelayer && !(0, import_viem2.isAddressEqual)(relayer, expectedRelayer))
+    throw pending();
+  await validateBody(scope, body, relayer);
+  const call = tokenBatchCall(body, attempt.phase);
+  if (tx.chainId !== body.chainId || !tx.to || !(0, import_viem2.isAddressEqual)(tx.to, call.to) || (tx.value ?? 0n) !== 0n || tx.data !== call.data || !Number.isSafeInteger(tx.nonce) || String(tx.nonce) !== attempt.nonce)
+    throw pending();
+  return relayer;
+}
+function terminalOf(value, attempts) {
+  if (!value || !["confirmed", "failed", "expired"].includes(value.kind) || !uint(value.blockNumber))
+    return;
+  if (value.kind === "confirmed" && (!value.txHash || !attempts.some(
+    (a) => a.phase === "deposit" && same(a.hash, value.txHash)
+  )))
+    return;
+  if (value.txHash !== void 0 && !hashPattern.test(value.txHash)) return;
+  return {
+    kind: value.kind,
+    blockNumber: value.blockNumber,
+    ...value.txHash ? { txHash: value.txHash } : {}
+  };
+}
+async function validateFamily(scope, raw2) {
+  if (!raw2 || raw2.version !== 1 || !Array.isArray(raw2.attempts) || !raw2.attempts.length || !raw2.current || !(0, import_viem2.isAddress)(raw2.relayer) || !hashPattern.test(raw2.authorizationId))
+    throw pending();
+  if (!same(tokenBatchAuthorizationId(raw2.body, raw2.relayer), raw2.authorizationId))
+    throw pending();
+  const seen = /* @__PURE__ */ new Map();
+  const roots = /* @__PURE__ */ new Set();
+  for (const a of raw2.attempts) {
+    await validateTokenBatchAttempt(scope, raw2.body, a, raw2.relayer);
+    if (seen.has(a.hash.toLowerCase())) throw pending();
+    if (a.predecessorHash) {
+      const predecessor = seen.get(a.predecessorHash.toLowerCase());
+      if (!predecessor || predecessor.phase !== a.phase || BigInt(a.nonce) <= BigInt(predecessor.nonce))
+        throw pending();
+    } else {
+      if (roots.has(a.phase)) throw pending();
+      roots.add(a.phase);
+    }
+    seen.set(a.hash.toLowerCase(), a);
+  }
+  for (const phase of ["approval", "deposit"]) {
+    const current = raw2.current[phase];
+    if (current && !raw2.attempts.some((a) => a.phase === phase && same(a.hash, current)))
+      throw pending();
+    if (raw2.attempts.some((a) => a.phase === phase) && !current)
+      throw pending();
+  }
+  return {
+    ...raw2,
+    body: tokenBatchStoredBody(raw2.body),
+    terminal: terminalOf(raw2.terminal, raw2.attempts)
+  };
+}
+async function importBody(scope, body) {
+  const attempts = [];
+  let relayer;
+  for (const phase of ["approval", "deposit"]) {
+    const bytes = phase === "approval" ? body.serializedPermitTransaction : body.serializedTransaction;
+    if (!bytes) continue;
+    const a = {
+      phase,
+      hash: (0, import_viem2.keccak256)(bytes),
+      serializedTransaction: bytes,
+      nonce: String((0, import_viem2.parseTransaction)(bytes).nonce),
+      preparedAt: 0,
+      submissionAttempted: true
+    };
+    relayer = await validateTokenBatchAttempt(scope, body, a, relayer);
+    attempts.push(a);
+  }
+  if (!relayer) return;
+  return {
+    version: 1,
+    authorizationId: tokenBatchAuthorizationId(body, relayer),
+    relayer,
+    body: tokenBatchStoredBody(body),
+    attempts,
+    current: Object.fromEntries(attempts.map((a) => [a.phase, a.hash]))
+  };
+}
+function merge(base7, incoming) {
+  if (!same(base7.authorizationId, incoming.authorizationId)) throw pending();
+  const attempts = base7.attempts.map((a) => ({ ...a }));
+  for (const a of incoming.attempts) {
+    const existing = attempts.find((x) => same(x.hash, a.hash));
+    if (existing) existing.submissionAttempted ||= a.submissionAttempted;
+    else attempts.push(a);
+  }
+  return { ...base7, attempts };
+}
+async function loadTokenBatchFamily(scope, expectedHash, allowMissing = false) {
+  try {
+    const key2 = tokenBatchKey(scope), records = /* @__PURE__ */ new Map();
+    for (const k of keys().filter((k2) => k2.startsWith(`${key2}:family:`))) {
+      const raw2 = tokenBatchRead(k);
+      if (!raw2) continue;
+      const family = await validateFamily(scope, JSON.parse(raw2));
+      if (k !== `${key2}:family:${family.authorizationId}`) throw pending();
+      records.set(family.authorizationId, family);
+    }
+    let projectedId;
+    const projection = tokenBatchRead(key2);
+    if (projection) {
+      const imported = await importBody(scope, JSON.parse(projection));
+      if (imported) {
+        projectedId = imported.authorizationId;
+        const stored = records.get(projectedId);
+        if (stored)
+          for (const attempt of imported.attempts) {
+            const known = stored.attempts.find(
+              (a) => same(a.hash, attempt.hash)
+            );
+            if (known) attempt.submissionAttempted = known.submissionAttempted;
+          }
+        records.set(
+          projectedId,
+          stored ? await validateFamily(scope, merge(stored, imported)) : imported
+        );
+      }
+    }
+    if (expectedHash) {
+      let found = [...records.values()].filter(
+        (f) => f.attempts.some((a) => same(a.hash, expectedHash))
+      );
+      if (!found.length) {
+        const archive = tokenBatchRead(
+          `${key2}:expired:${expectedHash.toLowerCase()}`
+        );
+        if (archive) {
+          const f = await importBody(scope, JSON.parse(archive));
+          if (f?.attempts.some((a) => same(a.hash, expectedHash))) found = [f];
+        }
+      }
+      if (!found.length && allowMissing) return;
+      if (found.length !== 1) throw pending();
+      return found[0];
+    }
+    const active2 = [...records.values()].filter(
+      (f) => !f.terminal || f.authorizationId === projectedId
+    );
+    if (active2.length > 1) throw pending();
+    return active2[0];
+  } catch (error) {
+    if (error instanceof OwneyError) throw error;
+    throw pending();
+  }
+}
+async function saveTokenBatchAttempt(scope, body, attempt, assertCurrent = () => {
+}) {
+  try {
+    const relayer = await validateTokenBatchAttempt(scope, body, attempt), id = tokenBatchAuthorizationId(body, relayer), key2 = tokenBatchKey(scope), sidecar = `${key2}:family:${id}`;
+    const prior = await loadTokenBatchFamily(scope);
+    if (prior && prior.authorizationId !== id) throw pending();
+    let family = prior ?? {
+      version: 1,
+      authorizationId: id,
+      relayer,
+      body: tokenBatchStoredBody(body),
+      attempts: [],
+      current: {}
+    };
+    const saved = tokenBatchRead(sidecar);
+    if (saved)
+      family = merge(await validateFamily(scope, JSON.parse(saved)), family);
+    const sameAttempt = family.attempts.find((a) => same(a.hash, attempt.hash));
+    if (sameAttempt)
+      sameAttempt.submissionAttempted ||= attempt.submissionAttempted;
+    else family.attempts.push({ ...attempt });
+    family.current[attempt.phase] = attempt.hash;
+    family.body = { ...tokenBatchStoredBody(body) };
+    for (const phase of ["approval", "deposit"]) {
+      const current = family.attempts.find(
+        (a) => a.hash === family.current[phase]
+      );
+      if (current)
+        family.body[phase === "deposit" ? "serializedTransaction" : "serializedPermitTransaction"] = current.serializedTransaction;
+    }
+    family = await validateFamily(scope, family);
+    if (tokenBatchRead(sidecar) !== saved)
+      throw pending(
+        "Deposit recovery data changed. Retry the existing deposit."
+      );
+    assertCurrent();
+    tokenBatchWrite(sidecar, JSON.stringify(family));
+    assertCurrent();
+    tokenBatchWrite(key2, JSON.stringify(family.body));
+    return family;
+  } catch (error) {
+    if (error instanceof OwneyError) throw error;
+    throw pending(
+      "Deposit recovery data could not be saved. The earlier transaction remains tracked."
+    );
+  }
+}
+function finishTokenBatchFamily(scope, family, terminal) {
+  const key2 = tokenBatchKey(scope), sidecar = `${key2}:family:${family.authorizationId}`;
+  try {
+    const saved = tokenBatchRead(sidecar), current = saved ? JSON.parse(saved) : family;
+    if (current.authorizationId !== family.authorizationId) return;
+    if (terminal.kind !== "confirmed" && current.attempts.some(
+      (a) => !family.attempts.some((known) => same(known.hash, a.hash))
+    ))
+      return;
+    const evidence = terminalOf(terminal, current.attempts);
+    if (!evidence) return;
+    tokenBatchWrite(
+      sidecar,
+      JSON.stringify({ ...current, terminal: evidence })
+    );
+    const projected = tokenBatchRead(key2);
+    if (projected && tokenBatchAuthorizationId(JSON.parse(projected), family.relayer) === family.authorizationId)
+      tokenBatchClear(key2, projected);
+  } catch {
+  }
+}
+var import_viem2, memory, settled, hashPattern, uint, same, tokenBatchKey, tokenBatchAuthorizationId, tokenBatchStoredBody, approvalAbi;
+var init_token_batch_family = __esm({
+  "src/lib/token-batch-family.ts"() {
+    "use strict";
+    import_viem2 = require("viem");
+    init_errors();
+    init_permit2_batch();
+    memory = /* @__PURE__ */ new Map();
+    settled = /* @__PURE__ */ new Map();
+    hashPattern = /^0x[\da-f]{64}$/i;
+    uint = (value) => typeof value === "string" && /^\d{1,78}$/.test(value) && BigInt(value) < 1n << 256n;
+    same = (a, b) => a.toLowerCase() === b.toLowerCase();
+    tokenBatchKey = (s) => `owney.token-batch.v1:${(0, import_viem2.keccak256)((0, import_viem2.toBytes)(s.apiKey))}:${s.baseUrl ?? "default"}:${s.chainId}:${s.owner.toLowerCase()}:${s.token.toLowerCase()}`;
+    tokenBatchAuthorizationId = (body, relayer) => (0, import_viem2.keccak256)(
+      (0, import_viem2.encodeAbiParameters)(
+        [{ type: "address" }, { type: "bytes32" }],
+        [body.from, (0, import_viem2.hashTypedData)(batchTypedData(body, relayer))]
+      )
+    );
+    tokenBatchStoredBody = (body) => ({
+      ...body,
+      transfers: body.transfers.map(({ to, amount }) => ({ to, amount }))
+    });
+    approvalAbi = (0, import_viem2.parseAbi)([
+      "function permit(address owner,address spender,uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s)"
+    ]);
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentChainIncompatibleError: () => AgentChainIncompatibleError,
+  AgentNotFoundError: () => AgentNotFoundError,
+  InvalidHistoryCursorError: () => InvalidHistoryCursorError,
+  NotConnectedError: () => NotConnectedError,
+  OwneyError: () => OwneyError,
+  OwneySDK: () => OwneySDK,
+  YieldseekerAgent: () => YieldseekerAgent,
+  clearWithdrawSwap: () => clearWithdrawSwap,
+  createOwneySIWX: () => createOwneySIWX,
+  listPendingDeposits: () => listPendingDeposits,
+  listPendingSwaps: () => listOrders,
+  listWithdrawSwaps: () => listWithdrawSwaps,
+  saveWithdrawSwap: () => saveWithdrawSwap,
+  setOwneyDebug: () => setOwneyDebug,
+  subscribeWithdrawSwaps: () => subscribeWithdrawSwaps,
+  updateWithdrawSwap: () => updateWithdrawSwap
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+init_token_batch_family();
+
+// src/lib/token-batch-observer.ts
+init_permit2_batch();
 
 // src/lib/funding-evidence.ts
-var import_viem2 = require("viem");
+var import_viem3 = require("viem");
 var import_account_abstraction = require("viem/account-abstraction");
 function notifyFunding(callback, evidence) {
   try {
@@ -257,9 +610,9 @@ function notifyFunding(callback, evidence) {
   } catch {
   }
 }
-var fullWithdrawalAbi = (0, import_viem2.parseAbi)(["function withdrawAllAssetToUser(address recipient, address asset)"]);
-var withdrawalEventAbi = (0, import_viem2.parseAbi)(["event WithdrewTokenToUser(address indexed owner, address indexed recipient, address indexed token, uint256 amount)"]);
-var accountExecutionAbi = (0, import_viem2.parseAbi)([
+var fullWithdrawalAbi = (0, import_viem3.parseAbi)(["function withdrawAllAssetToUser(address recipient, address asset)"]);
+var withdrawalEventAbi = (0, import_viem3.parseAbi)(["event WithdrewTokenToUser(address indexed owner, address indexed recipient, address indexed token, uint256 amount)"]);
+var accountExecutionAbi = (0, import_viem3.parseAbi)([
   "function execute(address target,uint256 value,bytes data)",
   "function executeBatch((address target,uint256 value,bytes data)[] calls)"
 ]);
@@ -269,7 +622,7 @@ function yieldseekerExecution(receipt, evidence) {
   const operationEvents = receipt.logs.flatMap((log) => {
     if (![entryPoint06, entryPoint07].includes(log.address.toLowerCase())) return [];
     try {
-      const event = (0, import_viem2.decodeEventLog)({ abi: import_account_abstraction.entryPoint06Abi, data: log.data, topics: log.topics });
+      const event = (0, import_viem3.decodeEventLog)({ abi: import_account_abstraction.entryPoint06Abi, data: log.data, topics: log.topics });
       return event.eventName === "UserOperationEvent" ? [{ ...event.args, logIndex: log.logIndex }] : [];
     } catch {
       return [];
@@ -292,7 +645,7 @@ function isFullYieldseekerWithdrawal(transaction, evidence, tokenAddress, receip
   if (evidence.agentId !== "yieldseeker" || transaction.chainId !== evidence.chainId || transaction.hash.toLowerCase() !== evidence.txHash?.toLowerCase() || !evidence.agentWallet) return false;
   const matchesFullCall = (data) => {
     try {
-      const decoded = (0, import_viem2.decodeFunctionData)({ abi: fullWithdrawalAbi, data });
+      const decoded = (0, import_viem3.decodeFunctionData)({ abi: fullWithdrawalAbi, data });
       return decoded.args[0].toLowerCase() === evidence.walletAddress.toLowerCase() && decoded.args[1].toLowerCase() === tokenAddress.toLowerCase();
     } catch {
       return false;
@@ -303,7 +656,7 @@ function isFullYieldseekerWithdrawal(transaction, evidence, tokenAddress, receip
     const address = transaction.to?.toLowerCase();
     if (address !== entryPoint06 && address !== entryPoint07) return false;
     const version = address === entryPoint06 ? "0.6" : "0.7";
-    const decoded = (0, import_viem2.decodeFunctionData)({ abi: version === "0.6" ? import_account_abstraction.entryPoint06Abi : import_account_abstraction.entryPoint07Abi, data: transaction.input });
+    const decoded = (0, import_viem3.decodeFunctionData)({ abi: version === "0.6" ? import_account_abstraction.entryPoint06Abi : import_account_abstraction.entryPoint07Abi, data: transaction.input });
     if (decoded.functionName !== "handleOps") return false;
     const operations = decoded.args[0].filter((operation2) => [evidence.agentWallet.toLowerCase(), evidence.walletAddress.toLowerCase()].includes(operation2.sender.toLowerCase()));
     if (operations.length !== 1) return false;
@@ -319,14 +672,14 @@ function isFullYieldseekerWithdrawal(transaction, evidence, tokenAddress, receip
     if (!receipt?.logs.some((log) => {
       if (log.address.toLowerCase() !== address) return false;
       try {
-        const event = (0, import_viem2.decodeEventLog)({ abi: import_account_abstraction.entryPoint06Abi, data: log.data, topics: log.topics });
+        const event = (0, import_viem3.decodeEventLog)({ abi: import_account_abstraction.entryPoint06Abi, data: log.data, topics: log.topics });
         return event.eventName === "UserOperationEvent" && event.args.userOpHash.toLowerCase() === hash2.toLowerCase() && event.args.sender.toLowerCase() === operation.sender.toLowerCase() && event.args.success;
       } catch {
         return false;
       }
     })) return false;
     if (operation.sender.toLowerCase() === evidence.agentWallet.toLowerCase()) return matchesFullCall(operation.callData);
-    const execution = (0, import_viem2.decodeFunctionData)({ abi: accountExecutionAbi, data: operation.callData });
+    const execution = (0, import_viem3.decodeFunctionData)({ abi: accountExecutionAbi, data: operation.callData });
     const calls = execution.functionName === "execute" ? [{ target: execution.args[0], value: execution.args[1], data: execution.args[2] }] : execution.args[0];
     return calls.length === 1 && calls[0].value === 0n && calls[0].target.toLowerCase() === evidence.agentWallet.toLowerCase() && matchesFullCall(calls[0].data);
   } catch {
@@ -369,7 +722,7 @@ function inspectFundingReceipt(receipt, evidence, tokenAddress, direction, optio
     if (seen.has(log.logIndex)) continue;
     seen.add(log.logIndex);
     try {
-      const event = (0, import_viem2.decodeEventLog)({ abi: import_viem2.erc20Abi, data: log.data, topics: log.topics });
+      const event = (0, import_viem3.decodeEventLog)({ abi: import_viem3.erc20Abi, data: log.data, topics: log.topics });
       if (event.eventName !== "Transfer") continue;
       const { from, to, value } = event.args;
       if (direction === "withdraw" && value === 0n && from.toLowerCase() === agent && to.toLowerCase() === owner)
@@ -393,7 +746,7 @@ function inspectFundingReceipt(receipt, evidence, tokenAddress, direction, optio
   const emptyPayout = direction === "withdraw" && evidence.agentId === "yieldseeker" && amount === 0n && zeroTransferLogs.length > 0 && execution.logs.some((log) => {
     if (log.address.toLowerCase() !== agent) return false;
     try {
-      const { args } = (0, import_viem2.decodeEventLog)({ abi: withdrawalEventAbi, data: log.data, topics: log.topics });
+      const { args } = (0, import_viem3.decodeEventLog)({ abi: withdrawalEventAbi, data: log.data, topics: log.topics });
       return args.owner.toLowerCase() === owner && args.recipient.toLowerCase() === owner && args.token.toLowerCase() === tokenAddress.toLowerCase() && args.amount === 0n;
     } catch {
       return false;
@@ -425,6 +778,218 @@ function inspectFundingReceipt(receipt, evidence, tokenAddress, direction, optio
   };
 }
 
+// src/lib/token-batch-observer.ts
+init_token_batch_family();
+var cursors = /* @__PURE__ */ new Map();
+async function observeTokenBatchFamily(input) {
+  let expired = false, timer;
+  const assertCurrent = () => {
+    if (expired || Date.now() >= input.deadlineAt)
+      throw Error("observation ended");
+    input.assertCurrent();
+  };
+  const run = async () => {
+    assertCurrent();
+    const { scope, pub } = input;
+    const family = await loadTokenBatchFamily(
+      scope,
+      input.family.attempts[0].hash
+    );
+    assertCurrent();
+    if (!family || family.authorizationId !== input.family.authorizationId)
+      return { status: "unresolved" };
+    const attempts = family.attempts.filter((a) => a.phase === "deposit");
+    const key2 = `${tokenBatchKey(scope)}:${family.authorizationId}`;
+    const start = (cursors.get(key2) ?? 0) % Math.max(1, attempts.length);
+    const ordered = [...attempts.slice(start), ...attempts.slice(0, start)];
+    const reverted = [];
+    for (let index = 0; index < ordered.length; index += 3) {
+      assertCurrent();
+      const group = ordered.slice(index, index + 3);
+      cursors.set(key2, (start + index + group.length) % attempts.length);
+      const observations = await Promise.all(
+        group.map(async (attempt) => {
+          try {
+            await validateTokenBatchAttempt(
+              scope,
+              family.body,
+              attempt,
+              family.relayer
+            );
+            assertCurrent();
+            const receipt = await pub.getTransactionReceipt({
+              hash: attempt.hash
+            });
+            assertCurrent();
+            if (receipt.transactionHash?.toLowerCase() !== attempt.hash.toLowerCase() || typeof receipt.blockNumber !== "bigint" || !receipt.blockHash)
+              return;
+            if (receipt.status === "reverted")
+              return { kind: "reverted", receipt };
+            if (receipt.status !== "success" || receipt.from?.toLowerCase() !== family.relayer.toLowerCase() || receipt.to?.toLowerCase() !== BATCH_PERMIT2_ADDRESS.toLowerCase())
+              return;
+            const exact = family.body.transfers.every(
+              (t) => inspectFundingReceipt(
+                receipt,
+                {
+                  agentId: "yieldseeker",
+                  chainId: family.body.chainId,
+                  token: "USDC",
+                  walletAddress: family.body.from,
+                  agentWallet: t.to,
+                  intendedAmount: t.amount,
+                  txHash: attempt.hash,
+                  transfer: "pending",
+                  registration: "pending",
+                  delivery: "not-applicable"
+                },
+                family.body.token,
+                "deposit",
+                { requireAmountMatch: true }
+              ).transfer === "confirmed"
+            );
+            return exact ? { kind: "confirmed", receipt } : void 0;
+          } catch {
+            return;
+          }
+        })
+      );
+      assertCurrent();
+      const winner = observations.find((o) => o?.kind === "confirmed");
+      if (winner) {
+        const latest2 = await loadTokenBatchFamily(
+          scope,
+          winner.receipt.transactionHash
+        );
+        assertCurrent();
+        if (!latest2) return { status: "unresolved" };
+        finishTokenBatchFamily(scope, latest2, {
+          kind: "confirmed",
+          txHash: winner.receipt.transactionHash,
+          blockNumber: winner.receipt.blockNumber.toString()
+        });
+        return {
+          status: "confirmed",
+          txHash: winner.receipt.transactionHash,
+          receipt: winner.receipt
+        };
+      }
+      for (const o of observations)
+        if (o?.kind === "reverted") reverted.push(o.receipt);
+    }
+    const latest = await loadTokenBatchFamily(scope, family.attempts[0].hash);
+    assertCurrent();
+    if (!latest) return { status: "unresolved" };
+    if (attempts.length > 0 && reverted.length === latest.attempts.filter((a) => a.phase === "deposit").length) {
+      const block2 = reverted.reduce(
+        (n, r) => r.blockNumber > n ? r.blockNumber : n,
+        0n
+      );
+      finishTokenBatchFamily(scope, latest, {
+        kind: "failed",
+        blockNumber: block2.toString()
+      });
+      return { status: "failed", receipts: reverted };
+    }
+    const block = await pub.getBlock({ blockTag: "finalized" });
+    assertCurrent();
+    if (typeof block.number !== "bigint" || !block.hash || typeof block.timestamp !== "bigint" || block.timestamp <= BigInt(family.body.deadline))
+      return { status: "unresolved" };
+    const nonce = BigInt(family.body.nonce);
+    const bitmap = await pub.readContract({
+      address: BATCH_PERMIT2_ADDRESS,
+      abi: PERMIT2_BATCH_ABI,
+      functionName: "nonceBitmap",
+      args: [family.body.from, nonce >> 8n],
+      blockNumber: block.number
+    });
+    assertCurrent();
+    if (typeof bitmap !== "bigint" || bitmap < 0n || bitmap >= 1n << 256n || (bitmap & 1n << (nonce & 255n)) !== 0n)
+      return { status: "unresolved" };
+    if ((await pub.getBlock({ blockNumber: block.number })).hash !== block.hash)
+      return { status: "unresolved" };
+    assertCurrent();
+    finishTokenBatchFamily(scope, latest, {
+      kind: "expired",
+      blockNumber: block.number.toString()
+    });
+    return { status: "expired", blockNumber: block.number };
+  };
+  try {
+    return await Promise.race([
+      run(),
+      new Promise((resolve) => {
+        timer = setTimeout(
+          () => {
+            expired = true;
+            resolve({ status: "unresolved" });
+          },
+          Math.max(0, input.deadlineAt - Date.now())
+        );
+      })
+    ]);
+  } catch {
+    return { status: "unresolved" };
+  } finally {
+    expired = true;
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// src/lib/swap/swap.observation.ts
+init_errors();
+var active = /* @__PURE__ */ new Set();
+var isOrderObserved = (key2) => active.has(key2);
+async function observeOrder(key2, run) {
+  const busy = () => new OwneyError(
+    "SWAP_REQUEST_FAILED",
+    "This order is already being observed.",
+    { orderHash: key2, watchActive: true, settlementUnconfirmed: true }
+  );
+  if (active.has(key2)) throw busy();
+  active.add(key2);
+  try {
+    if (typeof navigator !== "undefined" && navigator.locks)
+      return await navigator.locks.request(`owney.swap.observe:${key2}`, { ifAvailable: true }, (lock) => {
+        if (!lock) throw busy();
+        return run();
+      });
+    return await run();
+  } finally {
+    active.delete(key2);
+  }
+}
+
+// src/lib/swap/swap.deadline.ts
+async function bounded(work, timeoutMs, error) {
+  if (timeoutMs <= 0) throw error();
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(work),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(error()), timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function mapConcurrent(items, run, concurrency = 3) {
+  const results = new Array(items.length);
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    for (; ; ) {
+      const index = next++;
+      if (index >= items.length) return;
+      results[index] = await run(items[index]);
+    }
+  }));
+  return results;
+}
+
+// src/client.ts
+init_permit2_batch();
+
 // src/lib/helpers/funding-amount.ts
 function isFundingAmount(value, allowZero = false) {
   if (typeof value !== "string" || !/^\d{1,78}$/.test(value)) return false;
@@ -452,10 +1017,14 @@ function registerDepositBatch(callback, transfer) {
   batchCallbacks.set(callback, transfer);
 }
 
+// src/lib/sponsored-deposit.ts
+init_errors();
+
 // src/lib/transfer-auth.ts
-var import_viem3 = require("viem");
+var import_viem4 = require("viem");
 
 // src/lib/sponsor-client.ts
+init_errors();
 var ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function postPaymasterIntent(input) {
   const base7 = input.baseUrl ?? ROUTING_API_BASE_URL;
@@ -539,6 +1108,7 @@ async function postSponsorBatchTransfer(input) {
       `${input.baseUrl ?? ROUTING_API_BASE_URL}/api/v1/sponsor/permit2-batch`,
       {
         method: "POST",
+        ...input.signal ? { signal: input.signal } : {},
         headers: {
           "content-type": "application/json",
           "x-owney-api-key": input.apiKey
@@ -567,9 +1137,48 @@ async function postSponsorBatchTransfer(input) {
   }
   return parsed.data;
 }
+async function postSponsorBatchRecovery(input) {
+  const failure = () => new OwneyError("SPONSOR_REQUEST_FAILED", "Deposit recovery is unavailable. The existing transaction remains tracked.", { safeToFallback: false });
+  try {
+    input.signal?.throwIfAborted();
+    const response = await fetch(`${input.baseUrl ?? ROUTING_API_BASE_URL}/api/v1/sponsor/permit2-batch/recover`, { method: "POST", headers: { "content-type": "application/json", "x-owney-api-key": input.apiKey }, body: JSON.stringify(input.body), signal: input.signal });
+    input.signal?.throwIfAborted();
+    if (response.status === 404) return;
+    const payload = await response.json();
+    input.signal?.throwIfAborted();
+    if (!response.ok || payload?.success !== true) throw failure();
+    const value = payload.data;
+    const { isAddress: isAddress6, keccak256: keccak2565, parseTransaction: parseTransaction4, recoverTransactionAddress: recoverTransactionAddress2 } = await import("viem");
+    const { validateTokenBatchAttempt: validateTokenBatchAttempt2 } = await Promise.resolve().then(() => (init_token_batch_family(), token_batch_family_exports));
+    const phase = input.body.phase;
+    const original = phase === "approval" ? input.body.serializedPermitTransaction : input.body.serializedTransaction;
+    if (!original) throw failure();
+    const hash2 = keccak2565(original), relayer = await recoverTransactionAddress2({ serializedTransaction: original });
+    const validHash = (v) => typeof v === "string" && /^0x[\da-f]{64}$/i.test(v);
+    if (!value || value.protocol !== 1 || value.phase !== phase || !validHash(value.txHash) || !isAddress6(value.relayer) || value.relayer.toLowerCase() !== relayer.toLowerCase()) throw failure();
+    if (value.status !== "prepared" && value.txHash.toLowerCase() !== hash2.toLowerCase()) throw failure();
+    if (value.status === "unresolved") {
+      if (!["nonce-not-consumed", "authorization-used", "authorization-expired", "state-unavailable", "preparation-rejected", "relayer-changed"].includes(value.reason)) throw failure();
+    } else {
+      if (!("blockNumber" in value) || typeof value.blockNumber !== "string" || !/^\d{1,78}$/.test(value.blockNumber) || BigInt(value.blockNumber) >= 1n << 256n || !validHash(value.blockHash)) throw failure();
+      if (value.status === "prepared") {
+        if (value.predecessorHash?.toLowerCase() !== hash2.toLowerCase()) throw failure();
+        const tx = parseTransaction4(value.serializedTransaction), old = parseTransaction4(original);
+        if (!Number.isSafeInteger(tx.nonce) || tx.nonce <= old.nonce) throw failure();
+        await validateTokenBatchAttempt2({ apiKey: input.apiKey, baseUrl: input.baseUrl, chainId: input.body.chainId, owner: input.body.from, token: input.body.token }, input.body, { phase, hash: value.txHash, serializedTransaction: value.serializedTransaction, nonce: String(tx.nonce), predecessorHash: hash2, preparedAt: Date.now(), submissionAttempted: false }, relayer);
+      } else if (value.status === "included") {
+        if (value.outcome !== "success" && value.outcome !== "reverted") throw failure();
+      } else if (value.status !== "approval-satisfied" || phase !== "approval") throw failure();
+    }
+    input.signal?.throwIfAborted();
+    return value;
+  } catch {
+    throw failure();
+  }
+}
 
 // src/lib/permit2.ts
-var import_viem4 = require("viem");
+var import_viem5 = require("viem");
 var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
 var MAX_UINT256 = 2n ** 256n - 1n;
 function permit2ApprovalAmount(requiredAmount) {
@@ -610,7 +1219,7 @@ var ERC20_ALLOWANCE_ABI = [
 function randomPermit2Nonce() {
   const bytes = new Uint8Array(32);
   globalThis.crypto.getRandomValues(bytes);
-  return BigInt((0, import_viem4.bytesToHex)(bytes));
+  return BigInt((0, import_viem5.bytesToHex)(bytes));
 }
 async function readPermit2Allowance(publicClient, token, owner, blockNumber) {
   return publicClient.readContract({
@@ -631,6 +1240,7 @@ async function readErc20Balance(publicClient, token, owner) {
 }
 
 // src/lib/chain-guard.ts
+init_errors();
 var CHAIN_NAMES = {
   1: "Ethereum",
   8453: "Base",
@@ -704,6 +1314,9 @@ function makeVerificationAwareDepositCallback(implementation) {
   return callback;
 }
 
+// src/lib/agent-reads.ts
+init_errors();
+
 // src/lib/rate-limit.ts
 function rateLimitDelay(error, now = Date.now()) {
   const seen = /* @__PURE__ */ new Set();
@@ -1005,15 +1618,15 @@ function positionsEmpty(entries, chainId, token) {
 function hasEmptyWithdrawalSnapshot(raw2, chainId, token) {
   const snapshot = snapshotPortfolio(raw2);
   if (!snapshot) return false;
-  const pending = snapshot.portfolio.pendingAsyncWithdrawals;
-  if (pending !== void 0 && (!Array.isArray(pending) || pending.length > 0)) return false;
+  const pending2 = snapshot.portfolio.pendingAsyncWithdrawals;
+  if (pending2 !== void 0 && (!Array.isArray(pending2) || pending2.length > 0)) return false;
   return chainBalancesMatch(snapshot.chains, chainId, token, (balance) => zero(balance.balance)) && positionsEmpty(snapshot.entries, chainId, token);
 }
 function hasIdleOnlyWithdrawalSnapshot(raw2, chainId, token, decimals, idle) {
   const snapshot = snapshotPortfolio(raw2);
   if (!snapshot) return false;
-  const pending = snapshot.portfolio.pendingAsyncWithdrawals;
-  if (pending !== void 0 && (!Array.isArray(pending) || pending.some((value) => record(value)?.status !== "CLAIMED"))) return false;
+  const pending2 = snapshot.portfolio.pendingAsyncWithdrawals;
+  if (pending2 !== void 0 && (!Array.isArray(pending2) || pending2.some((value) => record(value)?.status !== "CLAIMED"))) return false;
   return chainBalancesMatch(snapshot.chains, chainId, token, (balance) => {
     const amount = units(balance.balance);
     return amount !== void 0 && amount <= idle && (balance.decimals === void 0 || balance.decimals === decimals);
@@ -1021,7 +1634,8 @@ function hasIdleOnlyWithdrawalSnapshot(raw2, chainId, token, decimals, idle) {
 }
 
 // src/agents/zyfai/zyfai.deposit.ts
-var import_viem5 = require("viem");
+var import_viem6 = require("viem");
+init_errors();
 
 // src/types/config.ts
 var P_SUPPORTED_CHAINS = {
@@ -1075,16 +1689,16 @@ async function submitZyfaiDeposit({ sdk, state, chain: chain2, amount, asset, sm
   const owner = state.walletAddress;
   const provider = state.provider;
   const token = SupportedAssets.find((value) => value.chainId === chain2.id && value.symbol === asset);
-  if (!token || !(0, import_viem5.isAddress)(owner) || !(0, import_viem5.isAddress)(smartWallet) || !/^\d+$/.test(amount) || BigInt(amount) <= 0n)
+  if (!token || !(0, import_viem6.isAddress)(owner) || !(0, import_viem6.isAddress)(smartWallet) || !/^\d+$/.test(amount) || BigInt(amount) <= 0n)
     throw new OwneyError("AGENT_INVALID_RESPONSE", "Invalid Zyfai deposit transfer.", { chainId: chain2.id, asset }, "zyfai");
   assertCurrent();
   const prepared = await sdk.prepareEnterPosition({ userAddress: owner, chainId: chain2.id, amount, asset, strategy: "aggressive" });
   assertCurrent();
-  const expectedData = (0, import_viem5.encodeFunctionData)({ abi: import_viem5.erc20Abi, functionName: "transfer", args: [smartWallet, BigInt(amount)] });
+  const expectedData = (0, import_viem6.encodeFunctionData)({ abi: import_viem6.erc20Abi, functionName: "transfer", args: [smartWallet, BigInt(amount)] });
   const transfer = prepared?.transfer;
   if (!transfer || transfer.safeAddress?.toLowerCase() !== smartWallet.toLowerCase() || transfer.tokenAddress?.toLowerCase() !== token.address.toLowerCase() || transfer.to?.toLowerCase() !== token.address.toLowerCase() || transfer.data?.toLowerCase() !== expectedData.toLowerCase() || transfer.value !== "0")
     throw new OwneyError("AGENT_INVALID_RESPONSE", "Zyfai prepared a different deposit transfer.", { chainId: chain2.id, asset }, "zyfai");
-  const wallet = (0, import_viem5.createWalletClient)({ account: owner, chain: chain2, transport: (0, import_viem5.custom)({
+  const wallet = (0, import_viem6.createWalletClient)({ account: owner, chain: chain2, transport: (0, import_viem6.custom)({
     request: async (args) => {
       assertCurrent();
       if (args.method === "eth_sendTransaction") {
@@ -1106,7 +1720,7 @@ async function submitZyfaiDeposit({ sdk, state, chain: chain2, amount, asset, sm
 
 // src/agents/zyfai/zyfai.agent.ts
 var import_sdk = require("@zyfai/sdk");
-var import_viem8 = require("viem");
+var import_viem9 = require("viem");
 var import_chains = require("viem/chains");
 
 // src/lib/debug.ts
@@ -1127,6 +1741,7 @@ function debugLog(scope, message, data) {
 }
 
 // src/lib/utils.ts
+init_errors();
 var isValidChainId = (chainId) => {
   if (!SUPPORTED_CHAIN_IDS.includes(chainId)) {
     throw new OwneyError(
@@ -1162,8 +1777,8 @@ function matchesAsset(symbol2, asset) {
 }
 
 // src/agents/zyfai/zyfai.mapper.ts
-var import_viem6 = require("viem");
-var exactHexAmount = (raw2, decimals) => (0, import_viem6.formatUnits)(BigInt(/^0x/i.test(raw2) ? raw2 : `0x${raw2}`), decimals);
+var import_viem7 = require("viem");
+var exactHexAmount = (raw2, decimals) => (0, import_viem7.formatUnits)(BigInt(/^0x/i.test(raw2) ? raw2 : `0x${raw2}`), decimals);
 var DECIMALS_BY_SYMBOL = {
   usdc: 6,
   weth: 18,
@@ -1202,7 +1817,7 @@ function resolveChainId(chain2) {
 }
 function mapPendingAllocations(raw2) {
   if (!Array.isArray(raw2)) return void 0;
-  const pending = [];
+  const pending2 = [];
   for (const entry of raw2) {
     if (typeof entry !== "object" || entry === null) continue;
     const e = entry;
@@ -1216,7 +1831,7 @@ function mapPendingAllocations(raw2) {
     } catch {
       continue;
     }
-    pending.push({
+    pending2.push({
       chainId: e.chainId,
       asset: e.tokenSymbol,
       amount,
@@ -1224,7 +1839,7 @@ function mapPendingAllocations(raw2) {
       ...typeof e.updatedAt === "string" && e.updatedAt !== "" ? { since: e.updatedAt } : {}
     });
   }
-  return pending.length > 0 ? pending : void 0;
+  return pending2.length > 0 ? pending2 : void 0;
 }
 function mapBalances(raw2, _chainId, smartWallet) {
   const portfolio = raw2.portfolio;
@@ -1262,7 +1877,7 @@ function mapBalances(raw2, _chainId, smartWallet) {
     // legacy `amount` fallback is hex. Runtime
     // getBalances payloads often carry one (e.g. 18 for WETH) — prefer that
     // when present, otherwise fall back to the per-symbol lookup.
-    amount: p.underlyingAmountWithFee ?? p.underlyingAmount ? (0, import_viem6.formatUnits)(
+    amount: p.underlyingAmountWithFee ?? p.underlyingAmount ? (0, import_viem7.formatUnits)(
       BigInt(p.underlyingAmountWithFee ?? p.underlyingAmount ?? "0"),
       tokenDecimals(
         p.token_symbol,
@@ -1664,6 +2279,9 @@ function decodeHistoryCursor(token) {
   return parsed;
 }
 
+// src/agents/zyfai/zyfai.agent.ts
+init_errors();
+
 // src/agents/zyfai/zyfai.auth-cache.ts
 var KEY_PREFIX = "owney.zyfai.session";
 var storage = () => {
@@ -1926,7 +2544,8 @@ function protocolsPolicyNeedsUpdate(current, desiredProtocols, desiredAutoSelect
 }
 
 // src/lib/paid-rpc.ts
-var import_viem7 = require("viem");
+var import_viem8 = require("viem");
+init_errors();
 var PAID_RPC_RETRY_COUNT = 3;
 var PAID_RPC_RETRY_DELAY_MS = 1e3;
 function configuredRpcProxyBaseUrl(baseUrl) {
@@ -1962,9 +2581,9 @@ function createPaidRpcClient(chain2, rpcUrls) {
     rpcUrls,
     chain2.id
   );
-  return (0, import_viem7.createPublicClient)({
+  return (0, import_viem8.createPublicClient)({
     chain: chain2,
-    transport: (0, import_viem7.http)(url, {
+    transport: (0, import_viem8.http)(url, {
       retryCount: PAID_RPC_RETRY_COUNT,
       retryDelay: PAID_RPC_RETRY_DELAY_MS
     })
@@ -2061,7 +2680,7 @@ async function withPaidRpcDiagnostics(operation, chainId, rpcMethod, agentId) {
 }
 
 // src/agents/zyfai/zyfai.agent.ts
-var ERC7579_IS_MODULE_INSTALLED_ABI = (0, import_viem8.parseAbi)([
+var ERC7579_IS_MODULE_INSTALLED_ABI = (0, import_viem9.parseAbi)([
   "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)"
 ]);
 var WETH_ADDRESS_BY_CHAIN = {
@@ -2079,7 +2698,7 @@ function belowMinimumCeiling(rejection, token, decimals) {
   const ceiling = (display) => {
     const places = display.split(".")[1]?.length ?? 0;
     if (places >= decimals) return void 0;
-    return (0, import_viem8.parseUnits)(display, decimals) + 5n * 10n ** BigInt(decimals - places - 1);
+    return (0, import_viem9.parseUnits)(display, decimals) + 5n * 10n ** BigInt(decimals - places - 1);
   };
   const idle = ceiling(rejection.idle);
   const minimum = ceiling(rejection.minimum);
@@ -2131,6 +2750,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
   connectedAddress = null;
   connectedChainId = null;
   smartWalletCache = /* @__PURE__ */ new Map();
+  smartWalletReads = /* @__PURE__ */ new Map();
   /**
    * `${eoa}:${chainId}` keys we have already tried createSessionKey for. Guards
    * against re-running it on every activation/deposit when Zyfai's
@@ -2148,6 +2768,9 @@ var ZyfaiAgent = class _ZyfaiAgent {
   fundingHistoryCache = /* @__PURE__ */ new Map();
   earningsReads = /* @__PURE__ */ new Map();
   earningsRefreshes = /* @__PURE__ */ new Map();
+  // Recalculation is wallet-wide across assets/chains. Bound attempts locally,
+  // including failures; a negative result must not trigger a POST every poll.
+  earningsCalculationAttempts = /* @__PURE__ */ new Map();
   earningsSnapshot = null;
   earningsGeneration = 0;
   balanceSnapshots = /* @__PURE__ */ new WeakMap();
@@ -2239,7 +2862,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
           }, asset.address, entry.action === "Withdraw" ? "withdraw" : "deposit");
           if (evidence.transfer === "confirmed" && evidence.confirmedAmount) {
             Object.assign(tx, {
-              amount: (0, import_viem8.formatUnits)(BigInt(evidence.confirmedAmount), asset.decimals),
+              amount: (0, import_viem9.formatUnits)(BigInt(evidence.confirmedAmount), asset.decimals),
               amountRaw: evidence.confirmedAmount,
               blockNumber: evidence.blockNumber,
               logIndexes: evidence.logIndexes,
@@ -2323,9 +2946,11 @@ var ZyfaiAgent = class _ZyfaiAgent {
     this.sdkHasConnected = true;
     const executionSdk = this.sdk;
     const generation = ++this.connectionGeneration;
+    this.smartWalletCache.clear();
+    this.smartWalletReads.clear();
     this.connectedAddress = null;
     this.connectedChainId = null;
-    const pending = (async () => {
+    const pending2 = (async () => {
       const address = await this.connectAccountWithRetry(
         state.provider,
         validChainId,
@@ -2336,12 +2961,12 @@ var ZyfaiAgent = class _ZyfaiAgent {
       this.connectedAddress = address;
       this.connectedChainId = validChainId;
     })();
-    this.connectAuthPromise = pending;
+    this.connectAuthPromise = pending2;
     this.connectAuthScope = scope;
     try {
-      await pending;
+      await pending2;
     } finally {
-      if (this.connectAuthPromise === pending) {
+      if (this.connectAuthPromise === pending2) {
         this.connectAuthPromise = null;
         this.connectAuthScope = null;
       }
@@ -2434,18 +3059,29 @@ var ZyfaiAgent = class _ZyfaiAgent {
     await this.connectAuth(state, chainId);
     const validChainId = isValidChainId(chainId);
     const ownerAddress = this.getAddress();
-    const cacheKey = `${ownerAddress}_${validChainId}`;
-    let smartWallet = this.smartWalletCache.get(cacheKey);
-    if (!smartWallet) {
-      const { address } = await this.sdk.getSmartWalletAddress(
-        ownerAddress,
-        validChainId
-      );
-      smartWallet = address;
-      this.smartWalletCache.set(cacheKey, smartWallet);
-    }
+    const smartWallet = await this.readSmartWallet(ownerAddress, validChainId);
     return { smartWallet, chainId: validChainId };
   }
+  /** Read-only resolution shared with recovery; never enters authentication. */
+  readSmartWallet(owner, chainId) {
+    const key2 = `${owner.toLowerCase()}_${chainId}`;
+    const cached = this.smartWalletCache.get(key2);
+    if (cached) return Promise.resolve(cached);
+    const existing = this.smartWalletReads.get(key2);
+    if (existing) return existing;
+    const generation = this.connectionGeneration;
+    const executionSdk = this.sdk;
+    const pending2 = Promise.resolve().then(() => executionSdk.getSmartWalletAddress(owner, chainId)).then(({ address }) => {
+      if (generation !== this.connectionGeneration || executionSdk !== this.sdk)
+        throw new OwneyError("NOT_CONNECTED", "Wallet changed while resolving Zyfai.", void 0, this.id);
+      this.smartWalletCache.set(key2, address);
+      return address;
+    }).finally(() => {
+      if (this.smartWalletReads.get(key2) === pending2) this.smartWalletReads.delete(key2);
+    });
+    this.smartWalletReads.set(key2, pending2);
+    return pending2;
+  }
   // --- IAgent: Connection lifecycle ---
   async disconnect() {
     const executionSdk = this.sdk;
@@ -2453,6 +3089,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
     this.earningsGeneration++;
     this.earningsReads.clear();
     this.earningsRefreshes.clear();
+    this.earningsCalculationAttempts.clear();
     this.earningsSnapshot = null;
     if (this.connectedAddress && this.connectedChainId !== null) {
       clearSession(this.connectedAddress, this.connectedChainId);
@@ -2462,6 +3099,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
     this.connectAuthPromise = null;
     this.connectAuthScope = null;
     this.smartWalletCache.clear();
+    this.smartWalletReads.clear();
     this.sdk = this.createSdk();
     this.sdkHasConnected = false;
     await executionSdk.disconnectAccount();
@@ -3068,7 +3706,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
         this.sdk.getPortfolio(owner).catch(() => void 0)
       ]);
       assertScope();
-      if (!(0, import_viem8.isAddress)(wallet.address) || !registered.smartWallet || registered.smartWallet.toLowerCase() !== wallet.address.toLowerCase())
+      if (!(0, import_viem9.isAddress)(wallet.address) || !registered.smartWallet || registered.smartWallet.toLowerCase() !== wallet.address.toLowerCase())
         throw new OwneyError(
           "AGENT_AUTH_FAILED",
           "Could not verify Zyfai's withdrawal wallet.",
@@ -3082,7 +3720,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
       if (!empty && ceiling === void 0) return;
       const idle = await this.getPublicClient(chainId).readContract({
         address: asset.address,
-        abi: import_viem8.erc20Abi,
+        abi: import_viem9.erc20Abi,
         functionName: "balanceOf",
         args: [wallet.address]
       }).catch(() => void 0);
@@ -3307,7 +3945,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
   // --- IAgent: Portfolio reads ---
   async getFundingWallet(state, chainId) {
-    return (await this.sdk.getSmartWalletAddress(state.walletAddress, isValidChainId(chainId))).address;
+    return this.readSmartWallet(state.walletAddress, isValidChainId(chainId));
   }
   /** A positive deployed Safe balance is a conservative planning floor. Zero
    * requires both the mapped Safe's exact idle balance and a fresh complete
@@ -3340,13 +3978,13 @@ var ZyfaiAgent = class _ZyfaiAgent {
         this.sdk.getSmartWalletByEOA(owner)
       ]);
       assertScope();
-      if (!(0, import_viem8.isAddress)(wallet.address) || wallet.isDeployed !== false && (wallet.isDeployed !== true || wallet.isOwner !== true) || !registered.smartWallet || registered.smartWallet.toLowerCase() !== wallet.address.toLowerCase()) throw unavailable();
+      if (!(0, import_viem9.isAddress)(wallet.address) || wallet.isDeployed !== false && (wallet.isDeployed !== true || wallet.isOwner !== true) || !registered.smartWallet || registered.smartWallet.toLowerCase() !== wallet.address.toLowerCase()) throw unavailable();
       const client = this.getPublicClient(validChainId);
       const blockNumber = await client.getBlockNumber({ cacheTime: 0 });
       assertScope();
       const idle = await client.readContract({
         address: asset.address,
-        abi: import_viem8.erc20Abi,
+        abi: import_viem9.erc20Abi,
         functionName: "balanceOf",
         args: [wallet.address],
         blockNumber
@@ -3403,7 +4041,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
     if (blockNumber < BigInt(evidence.blockNumber)) return void 0;
     const idle = await client.readContract({
       address: asset.address,
-      abi: import_viem8.erc20Abi,
+      abi: import_viem9.erc20Abi,
       functionName: "balanceOf",
       args: [balance.smartWallet],
       blockNumber
@@ -3422,17 +4060,22 @@ var ZyfaiAgent = class _ZyfaiAgent {
     const existing = this.earningsReads.get(key2);
     if (existing) return existing;
     const generation = this.earningsGeneration;
-    const pending = Promise.resolve().then(() => this.sdk.getOnchainEarnings(smartWallet)).then((raw2) => {
-      if (generation === this.earningsGeneration) {
+    const executionSdk = this.sdk;
+    const pending2 = Promise.resolve().then(() => {
+      if (generation !== this.earningsGeneration || executionSdk !== this.sdk)
+        throw new OwneyError("NOT_CONNECTED", "Wallet changed while reading Zyfai earnings.", void 0, this.id);
+      return executionSdk.getOnchainEarnings(smartWallet);
+    }).then((raw2) => {
+      if (generation === this.earningsGeneration && executionSdk === this.sdk) {
         this.earningsSnapshot = { key: key2, raw: raw2, at: Date.now() };
       }
       return raw2;
     }).finally(() => {
-      if (this.earningsReads.get(key2) === pending)
+      if (this.earningsReads.get(key2) === pending2)
         this.earningsReads.delete(key2);
     });
-    this.earningsReads.set(key2, pending);
-    return pending;
+    this.earningsReads.set(key2, pending2);
+    return pending2;
   }
   async getEarnings(state, chainId) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
@@ -3443,27 +4086,44 @@ var ZyfaiAgent = class _ZyfaiAgent {
     return mapEarnings(raw2, smartWallet);
   }
   async refreshEarnings(state, chainId) {
+    const generation = this.earningsGeneration;
+    await this.connectAuth(state, chainId);
+    const executionSdk = this.sdk;
+    const connectionGeneration = this.connectionGeneration;
+    const assertCurrent = () => {
+      if (generation !== this.earningsGeneration || connectionGeneration !== this.connectionGeneration || executionSdk !== this.sdk)
+        throw new OwneyError("NOT_CONNECTED", "Wallet changed while refreshing Zyfai earnings.", void 0, this.id);
+    };
+    assertCurrent();
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
+    assertCurrent();
     const key2 = this.earningsKey(state, chainId, smartWallet);
     const existing = this.earningsRefreshes.get(key2);
     if (existing) return existing;
-    const generation = this.earningsGeneration;
-    const pending = (async () => {
+    const pending2 = (async () => {
       const recent = this.earningsSnapshot;
       const current = recent?.key === key2 && Date.now() - recent.at < 5e3 ? recent.raw : await this.readEarnings(key2, smartWallet);
       const lastCheck = current.data.lastCheckTimestamp ? Date.parse(current.data.lastCheckTimestamp) : Number.NaN;
-      const isFresh = Number.isFinite(lastCheck) && Date.now() - lastCheck < EARNINGS_REFRESH_COOLDOWN_MS;
-      const earnings = isFresh ? current : await this.sdk.calculateOnchainEarnings(smartWallet);
-      if (!isFresh && generation === this.earningsGeneration) {
-        this.earningsSnapshot = { key: key2, raw: earnings, at: Date.now() };
-      }
+      const mapped = mapEarnings(current, smartWallet);
+      assertCurrent();
+      const now = Date.now();
+      const isFresh = Number.isFinite(lastCheck) && lastCheck <= now && now - lastCheck < EARNINGS_REFRESH_COOLDOWN_MS;
+      const negative = mapped.lifetimeEarnings < 0 || mapped.tokens.some((token) => Number(token.amount) < 0);
+      const calculationKey = JSON.stringify([state.walletAddress?.toLowerCase(), smartWallet.toLowerCase()]);
+      const attemptedAt = this.earningsCalculationAttempts.get(calculationKey);
+      const canCalculate = attemptedAt === void 0 || now - attemptedAt >= EARNINGS_REFRESH_COOLDOWN_MS;
+      if (isFresh && !negative || !canCalculate) return mapped;
+      this.earningsCalculationAttempts.set(calculationKey, now);
+      const earnings = await executionSdk.calculateOnchainEarnings(smartWallet);
+      assertCurrent();
+      this.earningsSnapshot = { key: key2, raw: earnings, at: Date.now() };
       return mapEarnings(earnings, smartWallet);
     })().finally(() => {
-      if (this.earningsRefreshes.get(key2) === pending)
+      if (this.earningsRefreshes.get(key2) === pending2)
         this.earningsRefreshes.delete(key2);
     });
-    this.earningsRefreshes.set(key2, pending);
-    return pending;
+    this.earningsRefreshes.set(key2, pending2);
+    return pending2;
   }
   async getAccountApy(state, chainId, days, tokenSymbol) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
@@ -3608,12 +4268,13 @@ var ZyfaiAgent = class _ZyfaiAgent {
 };
 
 // src/agents/yieldseeker/yieldseeker.agent.ts
-var import_viem14 = require("viem");
+var import_viem16 = require("viem");
 var import_chains4 = require("viem/chains");
+init_errors();
 
 // src/agents/yieldseeker/yieldseeker.auth.ts
 var import_siwe = require("siwe");
-var import_viem9 = require("viem");
+var import_viem10 = require("viem");
 var import_chains2 = require("viem/chains");
 
 // src/agents/yieldseeker/yieldseeker.auth-cache.ts
@@ -3728,7 +4389,7 @@ function createYieldseekerSiweMessage(address, chainId, dependencies = {}) {
   return new import_siwe.SiweMessage({
     scheme: url.protocol.slice(0, -1),
     domain: url.host,
-    address: (0, import_viem9.getAddress)(address),
+    address: (0, import_viem10.getAddress)(address),
     uri: url.origin,
     version: "1",
     chainId,
@@ -3828,15 +4489,15 @@ var YieldseekerAuth = class {
     clearYieldseekerSession(state.walletAddress, chainId);
   }
   async sign(state, chainId) {
-    const account = (0, import_viem9.getAddress)(state.walletAddress);
-    const publicClient = (0, import_viem9.createPublicClient)({
+    const account = (0, import_viem10.getAddress)(state.walletAddress);
+    const publicClient = (0, import_viem10.createPublicClient)({
       chain: import_chains2.base,
-      transport: (0, import_viem9.custom)(state.provider)
+      transport: (0, import_viem10.custom)(state.provider)
     });
-    const walletClient = (0, import_viem9.createWalletClient)({
+    const walletClient = (0, import_viem10.createWalletClient)({
       account,
       chain: import_chains2.base,
-      transport: (0, import_viem9.custom)(state.provider)
+      transport: (0, import_viem10.custom)(state.provider)
     });
     await ensureWalletOnChain(
       publicClient,
@@ -4003,7 +4664,8 @@ var YieldseekerApiClient = class {
 };
 
 // src/agents/yieldseeker/yieldseeker.mapper.ts
-var import_viem10 = require("viem");
+var import_viem11 = require("viem");
+init_errors();
 
 // src/lib/helpers/snapshot-apy.ts
 var DAY_MS = 864e5;
@@ -4070,7 +4732,7 @@ function raw(value, endpoint) {
   return BigInt(value);
 }
 function decimal(value, decimals, endpoint) {
-  return (0, import_viem10.formatUnits)(raw(value, endpoint), decimals);
+  return (0, import_viem11.formatUnits)(raw(value, endpoint), decimals);
 }
 function balanceRaw(value, endpoint) {
   const amount = raw(value, endpoint);
@@ -4078,10 +4740,10 @@ function balanceRaw(value, endpoint) {
   return amount;
 }
 function balanceDecimal(value, decimals, endpoint) {
-  return (0, import_viem10.formatUnits)(balanceRaw(value, endpoint), decimals);
+  return (0, import_viem11.formatUnits)(balanceRaw(value, endpoint), decimals);
 }
 function usd(rawAmount2, decimals, price) {
-  return Number((0, import_viem10.formatUnits)(rawAmount2, decimals)) * price;
+  return Number((0, import_viem11.formatUnits)(rawAmount2, decimals)) * price;
 }
 function percent(value) {
   const result = Number(value);
@@ -4107,7 +4769,7 @@ function assetAddressValue(record2, address) {
 }
 function position(value, asset, baseAssetDecimals) {
   const option = value?.vaultOption;
-  if (!option || typeof option.provider !== "string" || typeof option.name !== "string" || typeof option.address !== "string" || !(0, import_viem10.isAddress)(option.address)) {
+  if (!option || typeof option.provider !== "string" || typeof option.name !== "string" || typeof option.address !== "string" || !(0, import_viem11.isAddress)(option.address)) {
     return invalid("vault positions", "missing vault metadata");
   }
   return {
@@ -4200,7 +4862,7 @@ function mapYieldseekerEarnings(contexts) {
       chain: "BASE",
       chainId: 8453,
       asset: context.asset,
-      amount: (0, import_viem10.formatUnits)(amount, context.snapshot.baseAssetDecimals)
+      amount: (0, import_viem11.formatUnits)(amount, context.snapshot.baseAssetDecimals)
     });
     lifetimeEarnings += usd(
       amount,
@@ -4356,7 +5018,7 @@ function allocationLegs(value, context, requireAmount) {
     const symbol2 = typeof leg.assetSymbol === "string" ? leg.assetSymbol.toUpperCase() : "";
     if ((requireAmount || symbol2) && symbol2 !== context.asset && !(context.asset === "WETH" && symbol2 === "ETH"))
       return void 0;
-    if (typeof leg.vaultAddress !== "string" || !(0, import_viem10.isAddress)(leg.vaultAddress)) return void 0;
+    if (typeof leg.vaultAddress !== "string" || !(0, import_viem11.isAddress)(leg.vaultAddress)) return void 0;
     const rawAmount2 = typeof leg.rawAmount === "string" && /^\d+$/.test(leg.rawAmount) ? BigInt(leg.rawAmount) : typeof leg.rawAmount === "number" && Number.isSafeInteger(leg.rawAmount) ? BigInt(leg.rawAmount) : void 0;
     if (requireAmount && (rawAmount2 === void 0 || rawAmount2 <= 0n)) return void 0;
     const vault = leg.vaultAddress.toLowerCase();
@@ -4383,7 +5045,7 @@ function allocationEntry(action, context) {
     protocol: leg.protocol,
     pool: leg.pool,
     tokenSymbol: context.asset,
-    amount: (0, import_viem10.formatUnits)(leg.rawAmount, decimals)
+    amount: (0, import_viem11.formatUnits)(leg.rawAmount, decimals)
   }));
   const amountRaw = deposits.reduce((total, leg) => total + leg.rawAmount, 0n);
   const rebalance = withdrawals.length > 0;
@@ -4405,7 +5067,7 @@ function allocationEntry(action, context) {
       toProtocol: leg.protocol,
       ...leg.pool ? { toPool: leg.pool } : {},
       tokenSymbol: context.asset,
-      amount: (0, import_viem10.formatUnits)(leg.rawAmount, decimals),
+      amount: (0, import_viem11.formatUnits)(leg.rawAmount, decimals),
       status: "success"
     })) : [],
     transactions: [{
@@ -4415,7 +5077,7 @@ function allocationEntry(action, context) {
       tokenSymbol: context.asset,
       agentWallet: context.wallet.walletAddress,
       amountRaw: String(amountRaw),
-      amount: (0, import_viem10.formatUnits)(amountRaw, decimals)
+      amount: (0, import_viem11.formatUnits)(amountRaw, decimals)
     }]
   };
 }
@@ -4547,7 +5209,7 @@ function mapYieldseekerHistory(contexts, options) {
       const known = new Set(target.logIndexes ?? []);
       if (tx.logIndexes?.some((index) => !known.has(index))) {
         target.amountRaw = String(BigInt(target.amountRaw ?? "0") + BigInt(tx.amountRaw));
-        target.amount = (0, import_viem10.formatUnits)(
+        target.amount = (0, import_viem11.formatUnits)(
           BigInt(target.amountRaw),
           YIELDSEEKER_ASSET_METADATA[target.tokenSymbol].decimals
         );
@@ -4628,7 +5290,7 @@ function mapYieldseekerAgentApy(options, days) {
 }
 
 // src/lib/remaining-vault-balance.ts
-var import_viem11 = require("viem");
+var import_viem12 = require("viem");
 async function remainingVaultBalance(client, wallet, asset, vaults, blockNumber) {
   const addresses = [...new Set(vaults.map((value) => value.toLowerCase()))];
   if (addresses.length > 64) return void 0;
@@ -4639,8 +5301,8 @@ async function remainingVaultBalance(client, wallet, asset, vaults, blockNumber)
       blockNumber,
       allowFailure: true,
       contracts: batch.map((address) => ({
-        address: (0, import_viem11.getAddress)(address),
-        abi: import_viem11.erc20Abi,
+        address: (0, import_viem12.getAddress)(address),
+        abi: import_viem12.erc20Abi,
         functionName: "balanceOf",
         args: [wallet]
       }))
@@ -4650,15 +5312,15 @@ async function remainingVaultBalance(client, wallet, asset, vaults, blockNumber)
     for (let index = 0; index < batch.length; index++) {
       const result = balances[index];
       if (result?.status !== "success" || typeof result.result !== "bigint" || result.result < 0n) return void 0;
-      if (result.result > 0n) funded.push({ address: (0, import_viem11.getAddress)(batch[index]), shares: result.result });
+      if (result.result > 0n) funded.push({ address: (0, import_viem12.getAddress)(batch[index]), shares: result.result });
     }
     if (!funded.length) return 0n;
     const valuations = await client.multicall({
       blockNumber,
       allowFailure: true,
       contracts: funded.flatMap(({ address, shares }) => [
-        { address, abi: import_viem11.erc4626Abi, functionName: "asset" },
-        { address, abi: import_viem11.erc4626Abi, functionName: "convertToAssets", args: [shares] }
+        { address, abi: import_viem12.erc4626Abi, functionName: "asset" },
+        { address, abi: import_viem12.erc4626Abi, functionName: "convertToAssets", args: [shares] }
       ])
     });
     if (valuations.length !== funded.length * 2) return void 0;
@@ -4674,12 +5336,12 @@ async function remainingVaultBalance(client, wallet, asset, vaults, blockNumber)
 }
 
 // src/agents/yieldseeker/yieldseeker.wallet-version.ts
-var import_viem12 = require("viem");
+var import_viem13 = require("viem");
 var YIELDSEEKER_FACTORY = "0x9c7410a0faCAC60850C46eE5b58B518daec95130";
 var YIELDSEEKER_V1_IMPLEMENTATION = "0x32403455357589523435dB18b414057D7cE05051";
 var YIELDSEEKER_V2_IMPLEMENTATION = "0x613Db9c924ADB7A7A90c11b02Cce20c913E3Fe50";
 var ERC1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
-var walletAbi = (0, import_viem12.parseAbi)([
+var walletAbi = (0, import_viem13.parseAbi)([
   "function owner() view returns (address)",
   "function ownerAgentIndex() view returns (uint256)",
   "function baseAsset() view returns (address)",
@@ -4687,7 +5349,7 @@ var walletAbi = (0, import_viem12.parseAbi)([
   "function upgradeToLatest()",
   "event Upgraded(address indexed implementation)"
 ]);
-var factoryAbi = (0, import_viem12.parseAbi)([
+var factoryAbi = (0, import_viem13.parseAbi)([
   "function userWallets(address owner, uint256 index) view returns (address)",
   "function agentWalletImplementation() view returns (address)"
 ]);
@@ -4695,9 +5357,9 @@ function yieldseekerOwnerPath(code) {
   return !code || code === "0x" || /^0xef0100[0-9a-f]{40}$/i.test(code) ? "eoa" : "smart";
 }
 async function readYieldseekerWalletStatus(client, wallet, owner, asset, blockNumber) {
-  const agentWallet = (0, import_viem12.getAddress)(wallet);
-  const expectedOwner = (0, import_viem12.getAddress)(owner);
-  const expectedAsset = (0, import_viem12.getAddress)(asset);
+  const agentWallet = (0, import_viem13.getAddress)(wallet);
+  const expectedOwner = (0, import_viem13.getAddress)(owner);
+  const expectedAsset = (0, import_viem13.getAddress)(asset);
   const [code, ownerCode, slot, actualOwner, index, actualAsset, actualFactory, latest] = await Promise.all([
     client.getBytecode({ address: agentWallet, blockNumber }),
     client.getBytecode({ address: expectedOwner, blockNumber }),
@@ -4711,7 +5373,7 @@ async function readYieldseekerWalletStatus(client, wallet, owner, asset, blockNu
   if (!code || code === "0x" || !slot || /^0x0+$/.test(slot)) {
     throw new Error("Yieldseeker wallet is not a deployed ERC1967 proxy");
   }
-  const implementation = (0, import_viem12.getAddress)(`0x${slot.slice(-40)}`);
+  const implementation = (0, import_viem13.getAddress)(`0x${slot.slice(-40)}`);
   const mapped = await client.readContract({
     address: YIELDSEEKER_FACTORY,
     abi: factoryAbi,
@@ -4719,8 +5381,8 @@ async function readYieldseekerWalletStatus(client, wallet, owner, asset, blockNu
     args: [expectedOwner, index],
     blockNumber
   });
-  const verified = (0, import_viem12.isAddressEqual)(actualOwner, expectedOwner) && (0, import_viem12.isAddressEqual)(actualAsset, expectedAsset) && (0, import_viem12.isAddressEqual)(actualFactory, YIELDSEEKER_FACTORY) && (0, import_viem12.isAddressEqual)(mapped, agentWallet);
-  const version = !verified ? "unknown" : (0, import_viem12.isAddressEqual)(implementation, YIELDSEEKER_V2_IMPLEMENTATION) ? "v2" : (0, import_viem12.isAddressEqual)(implementation, YIELDSEEKER_V1_IMPLEMENTATION) ? "v1" : "unknown";
+  const verified = (0, import_viem13.isAddressEqual)(actualOwner, expectedOwner) && (0, import_viem13.isAddressEqual)(actualAsset, expectedAsset) && (0, import_viem13.isAddressEqual)(actualFactory, YIELDSEEKER_FACTORY) && (0, import_viem13.isAddressEqual)(mapped, agentWallet);
+  const version = !verified ? "unknown" : (0, import_viem13.isAddressEqual)(implementation, YIELDSEEKER_V2_IMPLEMENTATION) ? "v2" : (0, import_viem13.isAddressEqual)(implementation, YIELDSEEKER_V1_IMPLEMENTATION) ? "v1" : "unknown";
   return {
     agentWallet,
     owner: actualOwner,
@@ -4729,16 +5391,17 @@ async function readYieldseekerWalletStatus(client, wallet, owner, asset, blockNu
     implementation,
     version,
     verified,
-    upgradeAvailable: version === "v1" && (0, import_viem12.isAddressEqual)(latest, YIELDSEEKER_V2_IMPLEMENTATION)
+    upgradeAvailable: version === "v1" && (0, import_viem13.isAddressEqual)(latest, YIELDSEEKER_V2_IMPLEMENTATION)
   };
 }
 var YIELDSEEKER_UPGRADE_ABI = walletAbi;
 
 // src/agents/yieldseeker/yieldseeker.sponsored-withdraw.ts
-var import_viem13 = require("viem");
+var import_viem14 = require("viem");
 var import_account_abstraction2 = require("viem/account-abstraction");
 var import_accounts = require("viem/accounts");
 var import_chains3 = require("viem/chains");
+init_errors();
 var ENTRY_POINT_V06 = "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";
 var USER_OP_FEE_HEADROOM = 2n;
 var OBSERVATION_WINDOW_MS = 6e4;
@@ -4822,7 +5485,7 @@ function rpcDiagnostics(data) {
     details.revertName = data.revertName;
   if (typeof data?.aaCode === "string" && /^AA[0-9]{2}$/.test(data.aaCode)) details.aaCode = data.aaCode;
   if (typeof data?.panicCode === "string" && /^0x[0-9a-fA-F]{1,2}$/.test(data.panicCode)) {
-    const panicCode = (0, import_viem13.toHex)(BigInt(data.panicCode));
+    const panicCode = (0, import_viem14.toHex)(BigInt(data.panicCode));
     if (["0x0", "0x1", "0x11", "0x12", "0x21", "0x22", "0x31", "0x32", "0x41", "0x51"].includes(panicCode))
       details.panicCode = panicCode;
   }
@@ -4863,9 +5526,9 @@ function savePending(onPending, evidence, beforeSubmission = false) {
       );
   }
 }
-async function checkpoint(callback, pending) {
+async function checkpoint(callback, pending2) {
   try {
-    await callback?.(pending);
+    await callback?.(pending2);
   } catch {
     throw sponsorError(
       "Withdrawal status cannot be saved before submission.",
@@ -5042,14 +5705,14 @@ async function submitEoa(input) {
     throw sponsorError("Base did not return EIP-1559 gas fees.", true);
   let operation = {
     sender: input.agentWallet,
-    nonce: (0, import_viem13.toHex)(nonce),
+    nonce: (0, import_viem14.toHex)(nonce),
     initCode: "0x",
     callData: input.callData,
-    callGasLimit: (0, import_viem13.toHex)(3e5),
-    verificationGasLimit: (0, import_viem13.toHex)(3e5),
-    preVerificationGas: (0, import_viem13.toHex)(6e4),
-    maxFeePerGas: (0, import_viem13.toHex)(fees.maxFeePerGas * USER_OP_FEE_HEADROOM),
-    maxPriorityFeePerGas: (0, import_viem13.toHex)(fees.maxPriorityFeePerGas),
+    callGasLimit: (0, import_viem14.toHex)(3e5),
+    verificationGasLimit: (0, import_viem14.toHex)(3e5),
+    preVerificationGas: (0, import_viem14.toHex)(6e4),
+    maxFeePerGas: (0, import_viem14.toHex)(fees.maxFeePerGas * USER_OP_FEE_HEADROOM),
+    maxPriorityFeePerGas: (0, import_viem14.toHex)(fees.maxPriorityFeePerGas),
     paymasterAndData: "0x",
     signature: "0x"
   };
@@ -5057,7 +5720,7 @@ async function submitEoa(input) {
   const stub = await rpc(
     input.rpcUrl,
     "pm_getPaymasterStubData",
-    [operation, ENTRY_POINT_V06, (0, import_viem13.toHex)(8453), {}],
+    [operation, ENTRY_POINT_V06, (0, import_viem14.toHex)(8453), {}],
     "prepare"
   );
   if (!stub.paymasterAndData?.startsWith("0x"))
@@ -5072,7 +5735,7 @@ async function submitEoa(input) {
     const final = await rpc(
       input.rpcUrl,
       "pm_getPaymasterData",
-      [operation, ENTRY_POINT_V06, (0, import_viem13.toHex)(8453), {}],
+      [operation, ENTRY_POINT_V06, (0, import_viem14.toHex)(8453), {}],
       "prepare"
     );
     if (!final.paymasterAndData?.startsWith("0x"))
@@ -5082,10 +5745,10 @@ async function submitEoa(input) {
   const userOpHash = operationHash(operation);
   await assertOwnerSession(input.state, input.owner);
   assertIntentFresh(input.expiresAt);
-  const wallet = (0, import_viem13.createWalletClient)({
+  const wallet = (0, import_viem14.createWalletClient)({
     account: input.owner,
     chain: import_chains3.base,
-    transport: (0, import_viem13.custom)(input.state.provider)
+    transport: (0, import_viem14.custom)(input.state.provider)
   });
   input.assertCurrent?.();
   const signature = await wallet.signMessage({ message: { raw: userOpHash } });
@@ -5166,13 +5829,13 @@ async function submitSmart(input) {
   } catch {
     throw sponsorError("This account cannot check paymaster support on Base.", true);
   }
-  const supportsPaymaster = capabilities?.[(0, import_viem13.toHex)(8453)]?.paymasterService?.supported ?? capabilities?.["8453"]?.paymasterService?.supported ?? capabilities?.["0x0"]?.paymasterService?.supported;
+  const supportsPaymaster = capabilities?.[(0, import_viem14.toHex)(8453)]?.paymasterService?.supported ?? capabilities?.["8453"]?.paymasterService?.supported ?? capabilities?.["0x0"]?.paymasterService?.supported;
   if (supportsPaymaster !== true)
     throw sponsorError("This account cannot use a paymaster on Base.", true);
   await assertOwnerSession(input.state, input.owner);
   let sent;
   assertIntentFresh(input.expiresAt);
-  const requestedId = (0, import_viem13.toHex)(globalThis.crypto.getRandomValues(new Uint8Array(32)));
+  const requestedId = (0, import_viem14.toHex)(globalThis.crypto.getRandomValues(new Uint8Array(32)));
   savePending(input.onPending, { callsId: requestedId }, true);
   input.assertCurrent?.();
   await checkpoint(input.onBeforeSubmission, { callsId: requestedId });
@@ -5183,7 +5846,7 @@ async function submitSmart(input) {
       params: [{
         version: "2.0.0",
         from: input.owner,
-        chainId: (0, import_viem13.toHex)(8453),
+        chainId: (0, import_viem14.toHex)(8453),
         id: requestedId,
         atomicRequired: false,
         calls: [{ to: input.agentWallet, value: "0x0", data: input.callData }],
@@ -5258,7 +5921,7 @@ async function submitSmart(input) {
   );
 }
 async function submitYieldseekerSponsoredWithdrawal(input) {
-  const owner = (0, import_viem13.getAddress)(input.state.walletAddress);
+  const owner = (0, import_viem14.getAddress)(input.state.walletAddress);
   const { intent, rpcUrl } = await requestIntent({
     apiKey: input.apiKey,
     routingApiBaseUrl: input.routingApiBaseUrl,
@@ -5277,7 +5940,7 @@ async function submitYieldseekerSponsoredWithdrawal(input) {
   return intent.ownerPath === "eoa" ? submitEoa(args) : submitSmart(args);
 }
 async function submitYieldseekerSponsoredUpgrade(input) {
-  const owner = (0, import_viem13.getAddress)(input.state.walletAddress);
+  const owner = (0, import_viem14.getAddress)(input.state.walletAddress);
   const { intent, rpcUrl } = await requestIntent({
     apiKey: input.apiKey,
     routingApiBaseUrl: input.routingApiBaseUrl,
@@ -5297,6 +5960,57 @@ async function submitYieldseekerSponsoredUpgrade(input) {
   return submitSmart({ ...input, owner, rpcUrl, expiresAt: intent.expiresAt });
 }
 
+// src/agents/yieldseeker/yieldseeker.vault-reads.ts
+var import_viem15 = require("viem");
+var nativeAbi = (0, import_viem15.parseAbi)([
+  "function underlying() view returns (address)",
+  "function baseToken() view returns (address)",
+  "function UNDERLYING_ASSET_ADDRESS() view returns (address)",
+  "function balanceOfUnderlying(address owner) returns (uint256)"
+]);
+function nativeYieldseekerProtocol(option) {
+  switch (option.provider?.toLowerCase()) {
+    case "moonwell":
+      return "moonwell";
+    case "compound":
+      return "compound";
+    case "aave":
+      return "aave";
+    default:
+      return void 0;
+  }
+}
+function yieldseekerUnderlyingCall(option) {
+  const address = (0, import_viem15.getAddress)(option.address);
+  switch (nativeYieldseekerProtocol(option)) {
+    case "moonwell":
+      return { address, abi: nativeAbi, functionName: "underlying" };
+    case "compound":
+      return { address, abi: nativeAbi, functionName: "baseToken" };
+    case "aave":
+      return { address, abi: nativeAbi, functionName: "UNDERLYING_ASSET_ADDRESS" };
+    default:
+      return { address, abi: import_viem15.erc4626Abi, functionName: "asset" };
+  }
+}
+async function readNativeYieldseekerAssets(client, option, wallet, balance, blockNumber) {
+  if (nativeYieldseekerProtocol(option) !== "moonwell") {
+    return balance;
+  }
+  try {
+    const { data } = await client.call({
+      to: (0, import_viem15.getAddress)(option.address),
+      blockNumber,
+      data: (0, import_viem15.encodeFunctionData)({ abi: nativeAbi, functionName: "balanceOfUnderlying", args: [(0, import_viem15.getAddress)(wallet)] })
+    });
+    if (!data) return void 0;
+    const assets = (0, import_viem15.decodeFunctionResult)({ abi: nativeAbi, functionName: "balanceOfUnderlying", data });
+    return assets > 0n ? assets : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/agents/yieldseeker/yieldseeker.agent.ts
 var OWNEY_AGENT_NAME = "owney";
 var OWNEY_AGENT_RULE_PRESET = "explorative";
@@ -5306,7 +6020,8 @@ var YIELDSEEKER_USERNAME_CREATE_ATTEMPTS = 3;
 var YIELDSEEKER_VAULT_OPTIONS_CACHE_MS = 6e4;
 var YIELDSEEKER_AGENT_LIST_CACHE_MS = 12e4;
 var YIELDSEEKER_PORTFOLIO_CACHE_MS = 12e4;
-var YIELDSEEKER_SETTLEMENT_CACHE_MS = 5e3;
+var YIELDSEEKER_SETTLEMENT_BACKOFF_MS = [5e3, 1e4, 2e4, 4e4, 6e4];
+var YIELDSEEKER_SETTLEMENT_SNAPSHOT_WINDOW_MS = 10 * 6e4;
 var YIELDSEEKER_SETTLEMENT_ACTIVITY_CACHE_MS = 15e3;
 var YIELDSEEKER_READ_FAILURE_COOLDOWN_MS = 6e4;
 var YIELDSEEKER_SETTLEMENT_WINDOW_MS = 5 * 6e4;
@@ -5393,6 +6108,7 @@ var YieldseekerAgent = class {
   receiptClient;
   // A client preparation hint only; the routing API still checks live identity.
   withdrawalVersionCache = /* @__PURE__ */ new Map();
+  pendingWalletStatus = /* @__PURE__ */ new Map();
   pendingUpgrades = /* @__PURE__ */ new Map();
   transactionExecutor;
   unwindReceiptWaiter;
@@ -5409,6 +6125,7 @@ var YieldseekerAgent = class {
   liquidityVersions = /* @__PURE__ */ new Map();
   snapshotFailures = /* @__PURE__ */ new Map();
   standardReadFailures = /* @__PURE__ */ new Map();
+  endpointReadFailures = /* @__PURE__ */ new Map();
   reconcileUntil = /* @__PURE__ */ new Map();
   allocationRefresh = /* @__PURE__ */ new Set();
   activityRefreshUntil = /* @__PURE__ */ new Map();
@@ -5416,6 +6133,8 @@ var YieldseekerAgent = class {
   // settlement; keep slow reconciliation after the fast window expires.
   snapshotMovements = /* @__PURE__ */ new Map();
   movementEpochs = /* @__PURE__ */ new Map();
+  // Forced checks issued by the current movement's settlement schedule.
+  settlementChecks = /* @__PURE__ */ new Map();
   vaultOptions = /* @__PURE__ */ new Map();
   pendingVaultOptions = /* @__PURE__ */ new Map();
   constructor(owneyApiKey, options = {}) {
@@ -5439,19 +6158,31 @@ var YieldseekerAgent = class {
   async getWalletStatus(state, chainId, asset, useCachedV2 = false) {
     this.assertChain(chainId);
     this.assertAsset(asset);
+    const generation = this.readGeneration;
     const context = await this.findAgent(state, chainId, asset);
+    this.assertSession(generation, chainId, asset);
     if (!context) return null;
     const key2 = `${chainId}:${state.walletAddress.toLowerCase()}:${context.wallet.walletAddress.toLowerCase()}:${asset}`;
     const cached = this.withdrawalVersionCache.get(key2);
     if (useCachedV2 && cached && Date.now() - cached.at < 15 * 6e4) return { ...cached.status };
-    const status = await readYieldseekerWalletStatus(
+    const existing = this.pendingWalletStatus.get(key2);
+    if (existing) return { ...await existing };
+    const pending2 = readYieldseekerWalletStatus(
       this.getReceiptClient(),
-      (0, import_viem14.getAddress)(context.wallet.walletAddress),
-      (0, import_viem14.getAddress)(state.walletAddress),
+      (0, import_viem16.getAddress)(context.wallet.walletAddress),
+      (0, import_viem16.getAddress)(state.walletAddress),
       YIELDSEEKER_ASSET_METADATA[asset].address
-    );
-    this.rememberWalletStatus(key2, status);
-    return status;
+    ).then((status) => {
+      this.assertSession(generation, chainId, asset);
+      if (this.pendingWalletStatus.get(key2) !== pending2)
+        throw new OwneyError("AGENT_API_ERROR", "Yieldseeker wallet verification changed. Please retry.", void 0, this.id);
+      this.rememberWalletStatus(key2, status);
+      return status;
+    }).finally(() => {
+      if (this.pendingWalletStatus.get(key2) === pending2) this.pendingWalletStatus.delete(key2);
+    });
+    this.pendingWalletStatus.set(key2, pending2);
+    return { ...await pending2 };
   }
   rememberWalletStatus(key2, status) {
     if (status.verified && status.version === "v2") {
@@ -5477,12 +6208,13 @@ var YieldseekerAgent = class {
     const pendingKey2 = `owney.yieldseeker.upgrade:${before.owner.toLowerCase()}:${before.agentWallet.toLowerCase()}`;
     const confirmUpgrade = async (hash2, receipt2) => {
       this.withdrawalVersionCache.delete(versionKey);
-      const upgradeTopic = (0, import_viem14.encodeEventTopics)({ abi: YIELDSEEKER_UPGRADE_ABI, eventName: "Upgraded" })[0];
+      this.pendingWalletStatus.delete(versionKey);
+      const upgradeTopic = (0, import_viem16.encodeEventTopics)({ abi: YIELDSEEKER_UPGRADE_ABI, eventName: "Upgraded" })[0];
       const lastUpgrade = receipt2?.logs.filter((log) => log.address.toLowerCase() === before.agentWallet.toLowerCase() && log.topics[0] === upgradeTopic).at(-1);
       const expectedUpgrade = (() => {
         if (!lastUpgrade || lastUpgrade.removed) return false;
         try {
-          const event = (0, import_viem14.decodeEventLog)({ abi: YIELDSEEKER_UPGRADE_ABI, eventName: "Upgraded", data: lastUpgrade.data, topics: lastUpgrade.topics });
+          const event = (0, import_viem16.decodeEventLog)({ abi: YIELDSEEKER_UPGRADE_ABI, eventName: "Upgraded", data: lastUpgrade.data, topics: lastUpgrade.topics });
           return event.args.implementation.toLowerCase() === YIELDSEEKER_V2_IMPLEMENTATION.toLowerCase();
         } catch {
           return false;
@@ -5620,7 +6352,7 @@ var YieldseekerAgent = class {
         { version: before.version },
         this.id
       );
-    const data = (0, import_viem14.encodeFunctionData)({ abi: YIELDSEEKER_UPGRADE_ABI, functionName: "upgradeToLatest" });
+    const data = (0, import_viem16.encodeFunctionData)({ abi: YIELDSEEKER_UPGRADE_ABI, functionName: "upgradeToLatest" });
     let txHash;
     let receipt;
     if (gasMode === "sponsored") {
@@ -5646,9 +6378,9 @@ var YieldseekerAgent = class {
           agentWallet: before.agentWallet,
           asset: YIELDSEEKER_ASSET_METADATA[asset].address,
           callData: data,
-          onPending: (pending) => {
+          onPending: (pending2) => {
             const current = this.pendingUpgrades.has(pendingKey2) ? this.pendingUpgrades.get(pendingKey2) : JSON.parse(storage8.getItem(pendingKey2) ?? "null");
-            const next = { startedAt: Date.now(), ...current, ...pending };
+            const next = { startedAt: Date.now(), ...current, ...pending2 };
             storage8.setItem(pendingKey2, JSON.stringify(next));
             this.pendingUpgrades.delete(pendingKey2);
           }
@@ -5663,18 +6395,18 @@ var YieldseekerAgent = class {
       let submittedHash;
       try {
         txHash = await this.submitTransaction(state, chainId, {
-          from: (0, import_viem14.getAddress)(state.walletAddress),
+          from: (0, import_viem16.getAddress)(state.walletAddress),
           to: before.agentWallet,
           data,
           value: "0",
           chainId
         }, (hash2) => {
           submittedHash = hash2;
-          const pending = { txHash: hash2 };
-          this.pendingUpgrades.set(pendingKey2, pending);
+          const pending2 = { txHash: hash2 };
+          this.pendingUpgrades.set(pendingKey2, pending2);
           try {
             if (storage8) {
-              storage8.setItem(pendingKey2, JSON.stringify(pending));
+              storage8.setItem(pendingKey2, JSON.stringify(pending2));
               this.pendingUpgrades.delete(pendingKey2);
             }
           } catch {
@@ -5697,6 +6429,7 @@ var YieldseekerAgent = class {
   }
   async disconnect() {
     this.withdrawalVersionCache.clear();
+    this.pendingWalletStatus.clear();
     this.readGeneration += 1;
     this.auth.clear();
     for (const key2 of this.users.keys()) {
@@ -5714,11 +6447,13 @@ var YieldseekerAgent = class {
     this.liquidityVersions.clear();
     this.snapshotFailures.clear();
     this.standardReadFailures.clear();
+    this.endpointReadFailures.clear();
     this.reconcileUntil.clear();
     this.allocationRefresh.clear();
     this.activityRefreshUntil.clear();
     this.snapshotMovements.clear();
     this.movementEpochs.clear();
+    this.settlementChecks.clear();
   }
   async activateAgent(state, chainId, asset) {
     this.assertChain(chainId);
@@ -5771,12 +6506,12 @@ var YieldseekerAgent = class {
     } else {
       try {
         txHash = await this.submitTransaction(state, chainId, {
-          from: (0, import_viem14.getAddress)(state.walletAddress),
+          from: (0, import_viem16.getAddress)(state.walletAddress),
           to: YIELDSEEKER_ASSET_METADATA[asset].address,
-          data: (0, import_viem14.encodeFunctionData)({
-            abi: import_viem14.erc20Abi,
+          data: (0, import_viem16.encodeFunctionData)({
+            abi: import_viem16.erc20Abi,
             functionName: "transfer",
-            args: [(0, import_viem14.getAddress)(context.wallet.walletAddress), BigInt(amount)]
+            args: [(0, import_viem16.getAddress)(context.wallet.walletAddress), BigInt(amount)]
           }),
           value: "0",
           chainId
@@ -5839,7 +6574,10 @@ var YieldseekerAgent = class {
         ownerTransferAttempted = true;
       }, gasMode, onBeforeSubmission, assertOperation);
     } catch (error) {
-      if (error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED") this.withdrawalVersionCache.clear();
+      if (error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED") {
+        this.withdrawalVersionCache.clear();
+        this.pendingWalletStatus.clear();
+      }
       if (!ownerTransferAttempted || error?.code === 4001 || error instanceof OwneyError && (error.code === "AGENT_TRANSACTION_REVERTED" || error.details?.ownerTransferNotExecuted === true || error.code === "SPONSOR_REQUEST_FAILED" && (error.details?.safeToFallback === true || error.details?.executionFailed === true)))
         notifyFunding(onProgress, {
           ...evidence,
@@ -5922,7 +6660,7 @@ var YieldseekerAgent = class {
       );
       const positionsRead = this.readWithdrawalPositions(state, chainId, context);
       const metadata = YIELDSEEKER_ASSET_METADATA[asset];
-      const agentWallet = (0, import_viem14.getAddress)(context.wallet.walletAddress);
+      const agentWallet = (0, import_viem16.getAddress)(context.wallet.walletAddress);
       const readOwnerFunds = async (blockNumber) => {
         const feeTracker = await withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
           address: agentWallet,
@@ -5931,18 +6669,18 @@ var YieldseekerAgent = class {
           blockNumber
         }), chainId, "eth_call", this.id);
         this.assertSession(generation, chainId, asset);
-        if (!(0, import_viem14.isAddress)(feeTracker) || /^0x0{40}$/i.test(feeTracker))
+        if (!(0, import_viem16.isAddress)(feeTracker) || /^0x0{40}$/i.test(feeTracker))
           throw this.invalidResponse("wallet fee tracker");
         const [idle2, fees] = await Promise.all([
           withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
             address: metadata.address,
-            abi: import_viem14.erc20Abi,
+            abi: import_viem16.erc20Abi,
             functionName: "balanceOf",
             args: [agentWallet],
             blockNumber
           }), chainId, "eth_call", this.id),
           withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
-            address: (0, import_viem14.getAddress)(feeTracker),
+            address: (0, import_viem16.getAddress)(feeTracker),
             abi: YIELDSEEKER_FEE_TRACKER_ABI,
             functionName: "getFeesOwed",
             args: [agentWallet],
@@ -5984,21 +6722,35 @@ var YieldseekerAgent = class {
         let active2 = true;
         const checks = this.readVaultShares(values.map((position2) => position2.vaultOption), agentWallet, blockNumber).catch(() => []);
         const reads = values.map(async (position2, index) => {
-          const address = (0, import_viem14.getAddress)(position2.vaultOption.address);
+          const address = (0, import_viem16.getAddress)(position2.vaultOption.address);
           try {
             const group = (await checks).slice(index * 2, index * 2 + 2);
             if (!active2 || group.length !== 2 || group.some((value) => value.status !== "success")) return null;
             this.assertSession(generation, chainId, asset);
             const [underlying, shares] = group.map((value) => value.result);
-            if (typeof underlying !== "string" || !(0, import_viem14.isAddress)(underlying) || underlying.toLowerCase() !== metadata.address.toLowerCase() || typeof shares !== "bigint" || shares < 0n) return null;
+            if (typeof underlying !== "string" || !(0, import_viem16.isAddress)(underlying) || underlying.toLowerCase() !== metadata.address.toLowerCase() || typeof shares !== "bigint" || shares < 0n) return null;
             const verified = { ...position2, assetsRaw: shares.toString(), withdrawableAssetsRaw: "0" };
+            if (shares > 0n && nativeYieldseekerProtocol(position2.vaultOption)) {
+              const value = await readNativeYieldseekerAssets(
+                this.getReceiptClient(),
+                position2.vaultOption,
+                agentWallet,
+                shares,
+                blockNumber
+              );
+              if (!active2 || value === void 0) return null;
+              this.assertSession(generation, chainId, asset);
+              verified.withdrawableAssetsRaw = value.toString();
+              verifiedPositions.push(verified);
+              return verified;
+            }
             if (shares > 0n) {
               let positiveValue = false;
               const valuations = await Promise.all(["convertToAssets", "previewRedeem"].map(async (functionName) => {
                 try {
                   const value = await this.getReceiptClient().readContract({
                     address,
-                    abi: import_viem14.erc4626Abi,
+                    abi: import_viem16.erc4626Abi,
                     functionName,
                     args: [shares],
                     blockNumber
@@ -6239,7 +6991,7 @@ var YieldseekerAgent = class {
         delta: maxSettlementBasis.delta - payout,
         expectedNetDeposits: maxSettlementBasis.expectedNetDeposits - payout
       } : this.snapshotMovement(state, chainId, context, -payout);
-      const account = (0, import_viem14.getAddress)(state.walletAddress);
+      const account = (0, import_viem16.getAddress)(state.walletAddress);
       let receipt;
       const base7 = { agentId: this.id, chainId, token: asset, walletAddress: state.walletAddress, agentWallet: context.wallet.walletAddress, intendedAmount: amount ?? "MAX", transfer: "pending", registration: "not-applicable", delivery: "pending" };
       if (amount === void 0) base7.maxCompletion = {
@@ -6250,11 +7002,11 @@ var YieldseekerAgent = class {
       };
       if (base7.maxCompletion) notifyFunding(onProgress, base7);
       let submissionEvidence = base7;
-      const data = amount === void 0 ? (0, import_viem14.encodeFunctionData)({
+      const data = amount === void 0 ? (0, import_viem16.encodeFunctionData)({
         abi: YIELDSEEKER_AGENT_WALLET_ABI,
         functionName: "withdrawAllAssetToUser",
         args: [account, metadata.address]
-      }) : (0, import_viem14.encodeFunctionData)({
+      }) : (0, import_viem16.encodeFunctionData)({
         abi: YIELDSEEKER_AGENT_WALLET_ABI,
         functionName: "withdrawAssetToUser",
         args: [account, metadata.address, payout]
@@ -6271,16 +7023,16 @@ var YieldseekerAgent = class {
           refreshYieldseekerSignature: (rejected) => this.auth.refreshToken(state, chainId, rejected),
           userId: context.user.userId,
           agentId: context.agent.agentId,
-          agentWallet: (0, import_viem14.getAddress)(context.wallet.walletAddress),
+          agentWallet: (0, import_viem16.getAddress)(context.wallet.walletAddress),
           asset: metadata.address,
           callData: data,
-          onPending: (pending) => {
-            submissionEvidence = { ...submissionEvidence, ...pending };
+          onPending: (pending2) => {
+            submissionEvidence = { ...submissionEvidence, ...pending2 };
             notifyFunding(onProgress, submissionEvidence);
           },
-          onBeforeSubmission: async (pending) => {
+          onBeforeSubmission: async (pending2) => {
             assertOperation?.();
-            await onBeforeSubmission?.({ ...base7, ...pending });
+            await onBeforeSubmission?.({ ...base7, ...pending2 });
             onOwnerTransferAttempted?.();
           }
         });
@@ -6293,7 +7045,7 @@ var YieldseekerAgent = class {
           chainId,
           {
             from: account,
-            to: (0, import_viem14.getAddress)(context.wallet.walletAddress),
+            to: (0, import_viem16.getAddress)(context.wallet.walletAddress),
             data,
             value: "0",
             chainId
@@ -6423,7 +7175,7 @@ var YieldseekerAgent = class {
   async verifyWithdrawalCompletion(state, evidence) {
     const unknown = (reason2) => ({ status: "unavailable", reason: reason2 });
     const proof = evidence.maxCompletion;
-    if (evidence.agentId !== this.id || evidence.walletAddress.toLowerCase() !== state.walletAddress.toLowerCase() || evidence.chainId !== 8453 || !proof || !evidence.agentWallet || !(0, import_viem14.isAddress)(evidence.agentWallet) || !evidence.blockNumber || !/^\d+$/.test(evidence.blockNumber) || evidence.transfer !== "confirmed" || evidence.delivery !== "confirmed" || !this.isTransactionHash(evidence.txHash)) return unknown("PAYOUT_PROOF_UNAVAILABLE");
+    if (evidence.agentId !== this.id || evidence.walletAddress.toLowerCase() !== state.walletAddress.toLowerCase() || evidence.chainId !== 8453 || !proof || !evidence.agentWallet || !(0, import_viem16.isAddress)(evidence.agentWallet) || !evidence.blockNumber || !/^\d+$/.test(evidence.blockNumber) || evidence.transfer !== "confirmed" || evidence.delivery !== "confirmed" || !this.isTransactionHash(evidence.txHash)) return unknown("PAYOUT_PROOF_UNAVAILABLE");
     this.assertAsset(evidence.token);
     const asset = evidence.token;
     const metadata = YIELDSEEKER_ASSET_METADATA[asset];
@@ -6438,28 +7190,35 @@ var YieldseekerAgent = class {
         );
         if (!Array.isArray(response?.vaultPositions)) return unknown("CATALOG_INVALID");
         const positions = this.validateWithdrawalPositions(response.vaultPositions, evidence.chainId, asset);
-        const vaults = new Set([...proof.vaults, ...positions.map((p) => p.vaultOption.address)].map((a) => a.toLowerCase()));
-        if (!proof.inventoryComplete) {
-          const catalog = await this.loadVaultOptions(asset);
-          const eligible = catalog.filter((o) => o.chainId === evidence.chainId && o.assetAddress?.toLowerCase() === metadata.address.toLowerCase() && (0, import_viem14.isAddress)(o.address));
-          if (!eligible.length) return unknown("INVENTORY_INCOMPLETE");
-          eligible.forEach((o) => vaults.add(o.address.toLowerCase()));
+        const vaults = new Map(proof.vaults.map((address) => [address.toLowerCase(), { address }]));
+        positions.forEach((p) => vaults.set(p.vaultOption.address.toLowerCase(), p.vaultOption));
+        const needsInventory = !proof.inventoryComplete;
+        if (needsInventory || [...vaults.values()].some((option) => !option.provider)) {
+          const catalog = await this.loadVaultOptions(asset).catch(() => []);
+          const eligible = catalog.filter((o) => o.chainId === evidence.chainId && o.assetAddress?.toLowerCase() === metadata.address.toLowerCase() && (0, import_viem16.isAddress)(o.address));
+          if (needsInventory && !eligible.length) return unknown("INVENTORY_INCOMPLETE");
+          for (const option of eligible) {
+            const key2 = option.address.toLowerCase();
+            if (needsInventory || vaults.has(key2)) vaults.set(key2, option);
+          }
         }
-        if (vaults.size > YIELDSEEKER_WITHDRAWAL_CANDIDATE_LIMIT || [...vaults].some((a) => !(0, import_viem14.isAddress)(a)))
+        if (vaults.size > YIELDSEEKER_WITHDRAWAL_CANDIDATE_LIMIT || [...vaults.keys()].some((a) => !(0, import_viem16.isAddress)(a)))
           return unknown("INVENTORY_INVALID");
         reason = "VAULT_PROOF_UNAVAILABLE";
         const blockNumber = BigInt(evidence.blockNumber);
-        const addresses = [...vaults];
-        const shares = await this.readVaultShares(addresses.map((address) => ({ address })), evidence.agentWallet, blockNumber);
+        const options = [...vaults.values()];
+        const addresses = options.map((option) => option.address);
+        const shares = await this.readVaultShares(options, evidence.agentWallet, blockNumber);
         const checks = await Promise.all(addresses.map(async (address, i) => {
           const group = shares.slice(i * 2, i * 2 + 2);
           if (group.length !== 2 || group.some((r) => r.status !== "success")) return "unavailable";
           const [underlying, value] = group.map((r) => r.result);
           if (typeof underlying !== "string" || underlying.toLowerCase() !== metadata.address.toLowerCase() || typeof value !== "bigint" || value < 0n) return "unavailable";
           if (value === 0n) return "complete";
+          if (nativeYieldseekerProtocol(options[i])) return "remaining";
           const amounts = await Promise.allSettled(["convertToAssets", "previewRedeem"].map((functionName) => this.getReceiptClient().readContract({
-            address: (0, import_viem14.getAddress)(address),
-            abi: import_viem14.erc4626Abi,
+            address: (0, import_viem16.getAddress)(address),
+            abi: import_viem16.erc4626Abi,
             functionName,
             args: [value],
             blockNumber
@@ -6479,16 +7238,16 @@ var YieldseekerAgent = class {
     }
   }
   async readVaultShares(options, wallet, blockNumber) {
-    const owner = (0, import_viem14.getAddress)(wallet);
+    const owner = (0, import_viem16.getAddress)(wallet);
     const batches = Array.from({ length: Math.ceil(options.length / YIELDSEEKER_VAULTS_PER_RPC_BATCH) }, (_, index) => options.slice(index * YIELDSEEKER_VAULTS_PER_RPC_BATCH, (index + 1) * YIELDSEEKER_VAULTS_PER_RPC_BATCH));
     const results = await Promise.all(batches.map((batch) => this.getReceiptClient().multicall({
       blockNumber,
       allowFailure: true,
       contracts: batch.flatMap((option) => {
-        const address = (0, import_viem14.getAddress)(option.address);
+        const address = (0, import_viem16.getAddress)(option.address);
         return [
-          { address, abi: import_viem14.erc4626Abi, functionName: "asset" },
-          { address, abi: import_viem14.erc20Abi, functionName: "balanceOf", args: [owner] }
+          yieldseekerUnderlyingCall(option),
+          { address, abi: import_viem16.erc20Abi, functionName: "balanceOf", args: [owner] }
         ];
       })
     })));
@@ -6499,7 +7258,7 @@ var YieldseekerAgent = class {
     const seen = /* @__PURE__ */ new Set();
     for (const value of values) {
       const option = value?.vaultOption;
-      if (!option || typeof option.address !== "string" || !(0, import_viem14.isAddress)(option.address) || seen.has(option.address.toLowerCase()) || option.chainId !== void 0 && option.chainId !== chainId || option.assetAddress !== void 0 && (typeof option.assetAddress !== "string" || option.assetAddress.toLowerCase() !== underlying) || typeof value.assetsRaw !== "string" || !/^\d+$/.test(value.assetsRaw) || typeof value.withdrawableAssetsRaw !== "string" || !/^\d+$/.test(value.withdrawableAssetsRaw))
+      if (!option || typeof option.address !== "string" || !(0, import_viem16.isAddress)(option.address) || seen.has(option.address.toLowerCase()) || option.chainId !== void 0 && option.chainId !== chainId || option.assetAddress !== void 0 && (typeof option.assetAddress !== "string" || option.assetAddress.toLowerCase() !== underlying) || typeof value.assetsRaw !== "string" || !/^\d+$/.test(value.assetsRaw) || typeof value.withdrawableAssetsRaw !== "string" || !/^\d+$/.test(value.withdrawableAssetsRaw))
         throw this.invalidResponse("vault positions");
       seen.add(option.address.toLowerCase());
     }
@@ -6512,7 +7271,7 @@ var YieldseekerAgent = class {
     const historic = this.readCache.get(`historic:${key2}`)?.value?.position;
     const receivedAssets = new Set((historic?.movements ?? []).filter((movement) => movement.chainId === chainId && movement.agentWalletId === context.wallet.agentWalletId && movement.toAddress?.toLowerCase() === context.wallet.walletAddress.toLowerCase()).filter((movement) => typeof movement.assetAddress === "string").map((movement) => movement.assetAddress.toLowerCase()));
     for (const option of this.vaultOptions.get(context.asset)?.value ?? []) {
-      if (option.chainId !== chainId || typeof option.assetAddress !== "string" || option.assetAddress.toLowerCase() !== YIELDSEEKER_ASSET_METADATA[context.asset].address.toLowerCase() || !(0, import_viem14.isAddress)(option.address) || !receivedAssets.has(option.address.toLowerCase()) || hints.has(option.address.toLowerCase())) continue;
+      if (option.chainId !== chainId || typeof option.assetAddress !== "string" || option.assetAddress.toLowerCase() !== YIELDSEEKER_ASSET_METADATA[context.asset].address.toLowerCase() || !(0, import_viem16.isAddress)(option.address) || !receivedAssets.has(option.address.toLowerCase()) || hints.has(option.address.toLowerCase())) continue;
       hints.set(option.address.toLowerCase(), {
         vaultOption: option,
         assetsRaw: "0",
@@ -6566,7 +7325,7 @@ var YieldseekerAgent = class {
     const read2 = async () => {
       const client = this.getReceiptClient();
       const blockNumber = await client.getBlockNumber({ cacheTime: 0 });
-      const wallet = (0, import_viem14.getAddress)(context.wallet.walletAddress);
+      const wallet = (0, import_viem16.getAddress)(context.wallet.walletAddress);
       assertReadCurrent();
       if (typeof blockNumber !== "bigint") throw unavailable();
       const indexedPositions = this.validateWithdrawalPositions(positions ?? [], chainId, context.asset);
@@ -6579,7 +7338,7 @@ var YieldseekerAgent = class {
       const [idle, feeTracker] = await Promise.all([
         client.readContract({
           address: metadata.address,
-          abi: import_viem14.erc20Abi,
+          abi: import_viem16.erc20Abi,
           functionName: "balanceOf",
           args: [wallet],
           blockNumber
@@ -6591,10 +7350,10 @@ var YieldseekerAgent = class {
           blockNumber
         })
       ]);
-      if (typeof idle !== "bigint" || idle < 0n || !(0, import_viem14.isAddress)(feeTracker) || /^0x0{40}$/i.test(feeTracker)) throw unavailable();
+      if (typeof idle !== "bigint" || idle < 0n || !(0, import_viem16.isAddress)(feeTracker) || /^0x0{40}$/i.test(feeTracker)) throw unavailable();
       assertReadCurrent();
       const fees = await client.readContract({
-        address: (0, import_viem14.getAddress)(feeTracker),
+        address: (0, import_viem16.getAddress)(feeTracker),
         abi: YIELDSEEKER_FEE_TRACKER_ABI,
         functionName: "getFeesOwed",
         args: [wallet],
@@ -6646,7 +7405,7 @@ var YieldseekerAgent = class {
           const group = results.slice(index * 2, index * 2 + 2);
           if (group.length !== 2 || group.some((value2) => value2.status !== "success")) return false;
           const [underlying, shares] = group.map((value2) => value2.result);
-          if (typeof underlying !== "string" || !(0, import_viem14.isAddress)(underlying) || underlying.toLowerCase() !== metadata.address.toLowerCase() || typeof shares !== "bigint" || shares < 0n) return false;
+          if (typeof underlying !== "string" || !(0, import_viem16.isAddress)(underlying) || underlying.toLowerCase() !== metadata.address.toLowerCase() || typeof shares !== "bigint" || shares < 0n) return false;
           if (shares > 0n) known.add(option.address.toLowerCase());
           const position2 = {
             vaultOption: option,
@@ -6660,11 +7419,21 @@ var YieldseekerAgent = class {
           verified.push(position2);
           knownProof = proof(false);
           if (shares === 0n) return true;
+          if (nativeYieldseekerProtocol(option)) {
+            const value2 = await readNativeYieldseekerAssets(client, option, wallet, shares, blockNumber);
+            assertReadCurrent();
+            if (value2 === void 0) return false;
+            position2.withdrawableAssetsRaw = value2.toString();
+            position2.withdrawableAssetsBase = value2.toString();
+            deployed += value2;
+            knownProof = proof(false);
+            return true;
+          }
           let preview;
           try {
             const value2 = await client.readContract({
-              address: (0, import_viem14.getAddress)(option.address),
-              abi: import_viem14.erc4626Abi,
+              address: (0, import_viem16.getAddress)(option.address),
+              abi: import_viem16.erc4626Abi,
               functionName: "previewRedeem",
               args: [shares],
               blockNumber
@@ -6677,8 +7446,8 @@ var YieldseekerAgent = class {
           if (value === void 0 || value === 0n) {
             try {
               const converted = await client.readContract({
-                address: (0, import_viem14.getAddress)(option.address),
-                abi: import_viem14.erc4626Abi,
+                address: (0, import_viem16.getAddress)(option.address),
+                abi: import_viem16.erc4626Abi,
                 functionName: "convertToAssets",
                 args: [shares],
                 blockNumber
@@ -6718,7 +7487,7 @@ var YieldseekerAgent = class {
       assertReadCurrent();
       const eligible = /* @__PURE__ */ new Map();
       for (const option of catalog ?? []) {
-        if (option?.chainId === chainId && typeof option.assetAddress === "string" && option.assetAddress.toLowerCase() === metadata.address.toLowerCase() && (0, import_viem14.isAddress)(option.address))
+        if (option?.chainId === chainId && typeof option.assetAddress === "string" && option.assetAddress.toLowerCase() === metadata.address.toLowerCase() && (0, import_viem16.isAddress)(option.address))
           eligible.set(option.address.toLowerCase(), option);
       }
       const extra = [...eligible].filter(([address]) => !candidates.has(address)).map(([, option]) => option);
@@ -6769,7 +7538,7 @@ var YieldseekerAgent = class {
     const key2 = this.contextKey(state, evidence.chainId, evidence.token);
     const generation = this.readGeneration, version = this.portfolioVersion(key2);
     if (read2.readVersion !== version) return void 0;
-    const wallet = (0, import_viem14.getAddress)(context.wallet.walletAddress);
+    const wallet = (0, import_viem16.getAddress)(context.wallet.walletAddress);
     const asset = YIELDSEEKER_ASSET_METADATA[evidence.token];
     const client = this.getReceiptClient();
     const blockNumber = await client.getBlockNumber({ cacheTime: 0 });
@@ -6777,10 +7546,10 @@ var YieldseekerAgent = class {
     const vaults = [...this.balanceVaults.get(key2) ?? []];
     const [invested, idle, tracker] = await Promise.all([
       remainingVaultBalance(client, wallet, asset.address, vaults, blockNumber),
-      client.readContract({ address: asset.address, abi: import_viem14.erc20Abi, functionName: "balanceOf", args: [wallet], blockNumber }),
+      client.readContract({ address: asset.address, abi: import_viem16.erc20Abi, functionName: "balanceOf", args: [wallet], blockNumber }),
       client.readContract({ address: wallet, abi: YIELDSEEKER_AGENT_WALLET_ABI, functionName: "feeTracker", blockNumber })
     ]);
-    if (invested === void 0 || typeof idle !== "bigint" || idle < 0n || !(0, import_viem14.isAddress)(tracker) || /^0x0{40}$/i.test(tracker)) return void 0;
+    if (invested === void 0 || typeof idle !== "bigint" || idle < 0n || !(0, import_viem16.isAddress)(tracker) || /^0x0{40}$/i.test(tracker)) return void 0;
     const fees = await client.readContract({
       address: tracker,
       abi: YIELDSEEKER_FEE_TRACKER_ABI,
@@ -6793,7 +7562,7 @@ var YieldseekerAgent = class {
     const total = idle + invested > fees ? idle + invested - fees : 0n;
     const displayed = balance.assetBalances?.find((item) => item.chainId === evidence.chainId && item.asset === evidence.token);
     if (!displayed || !evidence.confirmedAmount || !/^\d+$/.test(evidence.confirmedAmount)) return void 0;
-    const amount = (0, import_viem14.parseUnits)(displayed.amount, asset.decimals);
+    const amount = (0, import_viem16.parseUnits)(displayed.amount, asset.decimals);
     if (amount < 0n) return void 0;
     const displayUnit = evidence.token === "USDC" ? 5000n : 500000000000n;
     const movementUnit = BigInt(evidence.confirmedAmount) / 1000n;
@@ -6810,16 +7579,18 @@ var YieldseekerAgent = class {
     if (failure && failure.retryAt > Date.now()) this.snapshotFailures.set(key2, failure);
     this.allocationRefresh.add(key2);
   }
-  invalidateFundingRead(state, chainId, asset, refreshUntil = Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS) {
+  invalidateFundingRead(state, chainId, asset, refreshUntil = Date.now() + YIELDSEEKER_SETTLEMENT_SNAPSHOT_WINDOW_MS) {
     this.assertAsset(asset);
     const key2 = this.contextKey(state, chainId, asset);
     const failure = this.snapshotFailures.get(key2);
     this.advancePortfolioVersion(key2);
     if (failure && failure.retryAt > Date.now()) this.snapshotFailures.set(key2, failure);
     if (!this.snapshotMovements.has(key2)) this.snapshotMovements.set(key2, null);
-    const until = Math.min(refreshUntil, Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS);
+    const until = Math.min(refreshUntil, Date.now() + YIELDSEEKER_SETTLEMENT_SNAPSHOT_WINDOW_MS);
+    const activityUntil = Math.min(refreshUntil, Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS);
+    if (until > Date.now()) this.beginSettlement(key2, false);
     this.reconcileUntil.set(key2, Math.max(this.reconcileUntil.get(key2) ?? 0, until));
-    this.activityRefreshUntil.set(key2, Math.max(this.activityRefreshUntil.get(key2) ?? 0, until));
+    this.activityRefreshUntil.set(key2, Math.max(this.activityRefreshUntil.get(key2) ?? 0, activityUntil));
   }
   endFundingBalanceRefresh(state, chainId, asset, read2) {
     this.assertChain(chainId);
@@ -6848,9 +7619,9 @@ var YieldseekerAgent = class {
     if (!context) return void 0;
     const idle = await withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
       address: YIELDSEEKER_ASSET_METADATA[asset].address,
-      abi: import_viem14.erc20Abi,
+      abi: import_viem16.erc20Abi,
       functionName: "balanceOf",
-      args: [(0, import_viem14.getAddress)(context.wallet.walletAddress)]
+      args: [(0, import_viem16.getAddress)(context.wallet.walletAddress)]
     }), chainId, "eth_call", this.id);
     this.assertSession(generation, chainId, asset);
     if (typeof idle !== "bigint" || idle < 0n) throw this.invalidResponse("wallet deposit balance");
@@ -6897,7 +7668,7 @@ var YieldseekerAgent = class {
     );
     const vaultAddresses = new Set(
       catalog.flat().filter(
-        (vaultOption) => vaultOption.chainId === chainId && (0, import_viem14.isAddress)(vaultOption.address)
+        (vaultOption) => vaultOption.chainId === chainId && (0, import_viem16.isAddress)(vaultOption.address)
       ).map((vaultOption) => vaultOption.address.toLowerCase())
     );
     return mapYieldseekerHistory(contexts, {
@@ -6931,8 +7702,8 @@ var YieldseekerAgent = class {
   async loadVaultOptions(asset) {
     const cached = this.vaultOptions.get(asset);
     if (cached && cached.expiresAt > Date.now()) return cached.value;
-    const pending = this.pendingVaultOptions.get(asset);
-    if (pending) return pending;
+    const pending2 = this.pendingVaultOptions.get(asset);
+    if (pending2) return pending2;
     const metadata = YIELDSEEKER_ASSET_METADATA[asset];
     const request2 = this.api.request(
       `/chains/8453/assets/${metadata.address}/vault-options`
@@ -6970,8 +7741,8 @@ var YieldseekerAgent = class {
     if (cached && cached.expiresAt > Date.now()) {
       return Promise.resolve(cached.value);
     }
-    const pending = this.pendingReads.get(key2);
-    if (pending) return pending;
+    const pending2 = this.pendingReads.get(key2);
+    if (pending2) return pending2;
     const generation = this.readGeneration;
     const requestedAt = Date.now();
     const request2 = Promise.resolve().then(read2).then((value) => {
@@ -7017,8 +7788,8 @@ var YieldseekerAgent = class {
     const key2 = this.contextKey(state, chainId, asset);
     const cached = this.agentContexts.get(key2);
     if (cached?.agent.agentId === agent.agentId) return cached;
-    const pending = this.pendingWalletContexts.get(key2);
-    if (pending) return pending;
+    const pending2 = this.pendingWalletContexts.get(key2);
+    if (pending2) return pending2;
     const generation = this.readGeneration;
     const request2 = this.walletRequest(
       state,
@@ -7026,7 +7797,7 @@ var YieldseekerAgent = class {
       `/users/${user.userId}/agents/${agent.agentId}/wallet`
     ).then((walletResponse) => {
       this.assertSession(generation, chainId, asset);
-      if (!walletResponse?.agentWallet || !(0, import_viem14.isAddress)(walletResponse.agentWallet.walletAddress)) {
+      if (!walletResponse?.agentWallet || !(0, import_viem16.isAddress)(walletResponse.agentWallet.walletAddress)) {
         throw this.invalidResponse("agent wallet");
       }
       const context = {
@@ -7056,7 +7827,7 @@ var YieldseekerAgent = class {
       this.users.set(key2, persisted);
       return persisted;
     }
-    const walletAddress = (0, import_viem14.getAddress)(state.walletAddress);
+    const walletAddress = (0, import_viem16.getAddress)(state.walletAddress);
     const generation = this.readGeneration;
     let user = null;
     try {
@@ -7118,8 +7889,8 @@ var YieldseekerAgent = class {
     const key2 = this.contextKey(state, chainId, asset);
     const cached = this.agentContexts.get(key2);
     if (cached) return cached;
-    const pending = this.pendingAgents.get(key2);
-    if (pending) return pending;
+    const pending2 = this.pendingAgents.get(key2);
+    if (pending2) return pending2;
     const generation = this.readGeneration;
     const request2 = this.resolveAgent(state, chainId, asset, true).then(
       async (context) => {
@@ -7229,8 +8000,21 @@ var YieldseekerAgent = class {
   portfolioVersion(contextKey) {
     return this.portfolioVersions.get(contextKey) ?? 0;
   }
+  /** Snapshot cache lifetime: the settlement backoff while a movement is being
+   * checked, otherwise the routine non-forced cadence. */
   portfolioCacheMs(contextKey) {
-    return (this.reconcileUntil.get(contextKey) ?? 0) > Date.now() ? YIELDSEEKER_SETTLEMENT_CACHE_MS : YIELDSEEKER_PORTFOLIO_CACHE_MS;
+    if ((this.reconcileUntil.get(contextKey) ?? 0) <= Date.now()) return YIELDSEEKER_PORTFOLIO_CACHE_MS;
+    const checks = this.settlementChecks.get(contextKey) ?? 0;
+    return YIELDSEEKER_SETTLEMENT_BACKOFF_MS[Math.min(checks, YIELDSEEKER_SETTLEMENT_BACKOFF_MS.length - 1)];
+  }
+  /** A pending movement inside its ten-minute window forces snapshots. */
+  settling(contextKey) {
+    return this.snapshotMovements.has(contextKey) && (this.reconcileUntil.get(contextKey) ?? 0) > Date.now();
+  }
+  /** Start a new forced-check schedule, or keep the active one. */
+  beginSettlement(contextKey, restart) {
+    if (!restart && (this.reconcileUntil.get(contextKey) ?? 0) > Date.now()) return;
+    this.settlementChecks.set(contextKey, 0);
   }
   snapshotMovement(state, chainId, context, delta) {
     const key2 = this.contextKey(state, chainId, context.asset);
@@ -7256,13 +8040,15 @@ var YieldseekerAgent = class {
       expectedNetDeposits: BigInt(snapshot.netDepositsBase) + delta
     };
   }
-  advancePortfolioVersion(contextKey, { snapshotOnly = false } = {}) {
+  advancePortfolioVersion(contextKey, { snapshotOnly = false, keepPositions = false } = {}) {
     const version = this.portfolioVersion(contextKey) + 1;
     this.portfolioVersions.set(contextKey, version);
     if (!snapshotOnly) this.liquidityVersions.set(contextKey, version);
     this.snapshotFailures.delete(contextKey);
-    for (const kind of ["snapshot", "positions", "historic", "actions"]) {
+    const kinds = !snapshotOnly ? ["snapshot", "positions", "historic", "actions"] : keepPositions ? ["snapshot"] : ["snapshot", "positions"];
+    for (const kind of kinds) {
       const key2 = `${kind}:${contextKey}`;
+      if (snapshotOnly && kind === "positions" && this.pendingReads.has(key2)) continue;
       this.readCache.delete(key2);
       this.pendingReads.delete(key2);
     }
@@ -7307,7 +8093,7 @@ var YieldseekerAgent = class {
     if ((!cached || cached.expiresAt <= Date.now()) && !this.pendingReads.has(key2)) {
       const failure = this.snapshotFailures.get(contextKey);
       if (failure && failure.retryAt > Date.now()) throw failure.error;
-      this.advancePortfolioVersion(contextKey, { snapshotOnly: true });
+      this.advancePortfolioVersion(contextKey, { snapshotOnly: true, keepPositions: this.settling(contextKey) });
     }
     const version = this.portfolioVersion(contextKey);
     const generation = this.readGeneration;
@@ -7315,6 +8101,8 @@ var YieldseekerAgent = class {
       version,
       read: this.cachedRead(key2, this.portfolioCacheMs(contextKey), () => {
         const allocationChanged = this.allocationRefresh.delete(contextKey);
+        const settling = this.settling(contextKey);
+        if (settling) this.settlementChecks.set(contextKey, (this.settlementChecks.get(contextKey) ?? 0) + 1);
         return this.requestPortfolioSnapshot(
           state,
           chainId,
@@ -7322,7 +8110,7 @@ var YieldseekerAgent = class {
           contextKey,
           version,
           generation,
-          allocationChanged || this.snapshotMovements.has(contextKey) && (this.reconcileUntil.get(contextKey) ?? 0) > Date.now()
+          allocationChanged || settling
         );
       })
     };
@@ -7392,7 +8180,7 @@ var YieldseekerAgent = class {
     const [positions, historic, actions] = await Promise.all([
       options.includePositions === false ? Promise.resolve({ vaultPositions: [] }) : this.cachedRead(
         `positions:${contextKey}`,
-        this.portfolioCacheMs(contextKey),
+        YIELDSEEKER_PORTFOLIO_CACHE_MS,
         async () => {
           const response = await this.walletRequest(
             state,
@@ -7439,7 +8227,7 @@ var YieldseekerAgent = class {
       this.agentPath(context, "deploy"),
       { method: "POST", body: {} }
     );
-    if (!deployed?.agentWallet || !(0, import_viem14.isAddress)(deployed.agentWallet.walletAddress) || deployed.agentWallet.walletAddress.toLowerCase() !== walletAddress) {
+    if (!deployed?.agentWallet || !(0, import_viem16.isAddress)(deployed.agentWallet.walletAddress) || deployed.agentWallet.walletAddress.toLowerCase() !== walletAddress) {
       throw this.invalidResponse("agent deployment", {
         reason: "Deploy did not return the expected Agent Wallet."
       });
@@ -7448,7 +8236,8 @@ var YieldseekerAgent = class {
   }
   async refreshSnapshotAfterMovement(state, chainId, context, movement, settlement) {
     const contextKey = this.contextKey(state, chainId, context.asset);
-    this.reconcileUntil.set(contextKey, Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS);
+    this.beginSettlement(contextKey, true);
+    this.reconcileUntil.set(contextKey, Date.now() + YIELDSEEKER_SETTLEMENT_SNAPSHOT_WINDOW_MS);
     this.activityRefreshUntil.set(contextKey, Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS);
     const epoch = this.movementEpochs.get(contextKey) ?? 0;
     this.snapshotMovements.set(contextKey, settlement?.epoch === epoch ? settlement : null);
@@ -7456,9 +8245,11 @@ var YieldseekerAgent = class {
     const version = this.advancePortfolioVersion(contextKey);
     const generation = this.readGeneration;
     try {
+      const ttl = this.portfolioCacheMs(contextKey);
+      this.settlementChecks.set(contextKey, 1);
       await this.cachedRead(
         `snapshot:${contextKey}`,
-        YIELDSEEKER_SETTLEMENT_CACHE_MS,
+        ttl,
         () => this.requestPortfolioSnapshot(state, chainId, context, contextKey, version, generation, true)
       );
     } catch (error) {
@@ -7474,10 +8265,14 @@ var YieldseekerAgent = class {
   async walletRequest(state, chainId, path, options = {}) {
     const read2 = (options.method ?? "GET") === "GET";
     const userKey = this.userKey(state, chainId);
+    const endpointKey = `${userKey}:${path}`;
     if (read2) {
       const failure = this.standardReadFailures.get(userKey);
       if (failure && failure.retryAt > Date.now()) throw failure.error;
       if (failure) this.standardReadFailures.delete(userKey);
+      const endpointFailure = this.endpointReadFailures.get(endpointKey);
+      if (endpointFailure && endpointFailure.retryAt > Date.now()) throw endpointFailure.error;
+      if (endpointFailure) this.endpointReadFailures.delete(endpointKey);
     }
     const generation = this.readGeneration;
     try {
@@ -7491,6 +8286,12 @@ var YieldseekerAgent = class {
           error: mapped
         });
       }
+      if (read2 && this.readGeneration === generation && error instanceof YieldseekerApiError && (error.status === 0 || error.status === 408 || error.status >= 500 && error.status < 600)) {
+        this.endpointReadFailures.set(endpointKey, {
+          retryAt: Date.now() + YIELDSEEKER_READ_FAILURE_COOLDOWN_MS,
+          error: mapped
+        });
+      }
       throw mapped;
     }
   }
@@ -7548,18 +8349,18 @@ var YieldseekerAgent = class {
       return hash3;
     }
     this.assertTransaction(transaction, state, chainId);
-    const account = (0, import_viem14.getAddress)(state.walletAddress);
-    const walletClient = (0, import_viem14.createWalletClient)({
+    const account = (0, import_viem16.getAddress)(state.walletAddress);
+    const walletClient = (0, import_viem16.createWalletClient)({
       account,
       chain: import_chains4.base,
-      transport: onBeforeSubmission ? (0, import_viem14.custom)({ request: async (args) => {
+      transport: onBeforeSubmission ? (0, import_viem16.custom)({ request: async (args) => {
         if (args.method === "eth_sendTransaction") await onBeforeSubmission();
         return state.provider.request(args);
-      } }, { retryCount: 0 }) : (0, import_viem14.custom)(state.provider)
+      } }, { retryCount: 0 }) : (0, import_viem16.custom)(state.provider)
     });
-    const walletChainClient = (0, import_viem14.createPublicClient)({
+    const walletChainClient = (0, import_viem16.createPublicClient)({
       chain: import_chains4.base,
-      transport: (0, import_viem14.custom)(state.provider)
+      transport: (0, import_viem16.custom)(state.provider)
     });
     await ensureWalletOnChain(
       walletChainClient,
@@ -7569,7 +8370,7 @@ var YieldseekerAgent = class {
     const hash2 = await walletClient.sendTransaction({
       account,
       chain: import_chains4.base,
-      to: (0, import_viem14.getAddress)(transaction.to),
+      to: (0, import_viem16.getAddress)(transaction.to),
       data: transaction.data,
       value: BigInt(transaction.value)
     });
@@ -7673,12 +8474,12 @@ var YieldseekerAgent = class {
     return receipt;
   }
   assertTransaction(transaction, state, chainId) {
-    if (!transaction || typeof transaction.from !== "string" || !(0, import_viem14.isAddress)(transaction.from) || typeof transaction.to !== "string" || !(0, import_viem14.isAddress)(transaction.to) || typeof transaction.data !== "string" || !/^0x[a-fA-F0-9]*$/.test(transaction.data) || typeof transaction.value !== "string" || !/^[0-9]+$/.test(transaction.value) || transaction.chainId !== chainId || (0, import_viem14.getAddress)(transaction.from) !== (0, import_viem14.getAddress)(state.walletAddress)) {
+    if (!transaction || typeof transaction.from !== "string" || !(0, import_viem16.isAddress)(transaction.from) || typeof transaction.to !== "string" || !(0, import_viem16.isAddress)(transaction.to) || typeof transaction.data !== "string" || !/^0x[a-fA-F0-9]*$/.test(transaction.data) || typeof transaction.value !== "string" || !/^[0-9]+$/.test(transaction.value) || transaction.chainId !== chainId || (0, import_viem16.getAddress)(transaction.from) !== (0, import_viem16.getAddress)(state.walletAddress)) {
       throw this.invalidResponse("transaction");
     }
   }
   assertAgent(agent) {
-    if (typeof agent.agentId !== "string" || typeof agent.assetAddress !== "string" || !(0, import_viem14.isAddress)(agent.assetAddress) || agent.chainId !== 8453) {
+    if (typeof agent.agentId !== "string" || typeof agent.assetAddress !== "string" || !(0, import_viem16.isAddress)(agent.assetAddress) || agent.chainId !== 8453) {
       throw this.invalidResponse("agent");
     }
   }
@@ -7734,6 +8535,7 @@ var YieldseekerAgent = class {
 };
 
 // src/lib/routing-api.ts
+init_errors();
 var ROUTING_API_BASE_URL2 = "https://owney-routing-api-243946518160.europe-west4.run.app";
 var getRoutingApiBaseUrl = (override) => override ?? ROUTING_API_BASE_URL2;
 async function fetchOrgAgentConfig(apiKey, baseUrl = ROUTING_API_BASE_URL2) {
@@ -7798,7 +8600,11 @@ async function fetchAgentKeys(apiKey, baseUrl = ROUTING_API_BASE_URL2) {
   return json.data;
 }
 
+// src/client.ts
+init_errors();
+
 // src/lib/swap/swap-api.ts
+init_errors();
 async function request(baseUrl, apiKey, path, init) {
   const url = `${baseUrl}/api/v1/swap${path}`;
   const controller = new AbortController();
@@ -7975,7 +8781,7 @@ function createSwapApi(baseUrl, apiKey) {
 }
 
 // src/lib/swap/swap.rpc.ts
-var import_viem15 = require("viem");
+var import_viem17 = require("viem");
 var DEFAULT_RPC_URLS = {
   // NOT cloudflare-eth.com, which used to lead this list. It answers
   // eth_chainId happily, errors on eth_blockNumber, and — the part that
@@ -8015,16 +8821,17 @@ var DEFAULT_RPC_URLS = {
 };
 function swapReadTransport(chainId, overrides) {
   const override = overrides?.[chainId];
-  if (override) return (0, import_viem15.http)(override);
+  if (override) return (0, import_viem17.http)(override);
   const urls = DEFAULT_RPC_URLS[chainId];
-  if (!urls || urls.length === 0) return (0, import_viem15.http)();
-  return (0, import_viem15.fallback)(urls.map((url) => (0, import_viem15.http)(url)));
+  if (!urls || urls.length === 0) return (0, import_viem17.http)();
+  return (0, import_viem17.fallback)(urls.map((url) => (0, import_viem17.http)(url)));
 }
 function receiptTimeoutMs(chainId) {
   return chainId === 1 ? 6e5 : 18e4;
 }
 
 // src/lib/swap/swap.wrap.ts
+init_errors();
 var WRAP_SELECTOR = "0xd0e30db0";
 var FALLBACK_WRAP_GAS = 50000n;
 var APPROVE_GAS = 60000n;
@@ -8128,7 +8935,11 @@ function swapChain(chainId) {
   return CHAINS[chainId];
 }
 
+// src/lib/swap/swap.executor.ts
+init_errors();
+
 // src/lib/swap/swap.arrival.ts
+init_errors();
 var DEFAULT_TIMEOUT_MS = 18e4;
 var DEFAULT_POLL_MS = 4e3;
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -8183,7 +8994,7 @@ async function awaitBalanceIncrease(options) {
 }
 
 // src/lib/swap/swap.secrets.ts
-var import_viem16 = require("viem");
+var import_viem18 = require("viem");
 var SECRET_BYTES = 32;
 function randomBytes(length) {
   const bytes = new Uint8Array(length);
@@ -8205,13 +9016,16 @@ function mintSecrets(count) {
   const secrets = [];
   const secretHashes = [];
   for (let i = 0; i < count; i++) {
-    const secret = (0, import_viem16.toHex)(randomBytes(SECRET_BYTES));
+    const secret = (0, import_viem18.toHex)(randomBytes(SECRET_BYTES));
     secrets.push(secret);
-    secretHashes.push((0, import_viem16.keccak256)(secret));
+    secretHashes.push((0, import_viem18.keccak256)(secret));
   }
   return { secrets, secretHashes };
 }
 
+// src/lib/swap/swap.order-runner.ts
+init_errors();
+
 // src/lib/swap/swap.types.ts
 var SWAP_TERMINAL_STATUSES = [
   "executed",
@@ -8322,6 +9136,7 @@ function runFusionOrder(deps, options) {
 }
 
 // src/lib/swap/swap.same-chain-runner.ts
+init_errors();
 var DEFAULT_POLL_MS3 = 5e3;
 var MAX_BACKOFF_MS2 = 3e4;
 var backoffFor2 = (failures, base7) => Math.min(base7 * 2 ** Math.min(failures, 5), MAX_BACKOFF_MS2);
@@ -8440,12 +9255,12 @@ function listOrders(_now = Date.now()) {
   if (!store) return [];
   const out = [];
   try {
-    const keys = [];
+    const keys2 = [];
     for (let i = 0; i < store.length; i++) {
       const key2 = store.key(i);
-      if (key2?.startsWith(`${KEY_PREFIX4}.`)) keys.push(key2);
+      if (key2?.startsWith(`${KEY_PREFIX4}.`)) keys2.push(key2);
     }
-    for (const key2 of keys) {
+    for (const key2 of keys2) {
       const raw2 = store.getItem(key2);
       if (!raw2) continue;
       try {
@@ -8832,6 +9647,7 @@ function submissionUnknown(error, orderHash) {
 }
 
 // src/lib/swap/swap.withdrawal-settlement.ts
+init_errors();
 var rawAmount = (value) => typeof value === "string" && /^\d+$/.test(value) ? BigInt(value) : void 0;
 var hash = (value) => typeof value === "string" && /^0x[\da-f]{64}$/i.test(value);
 var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -8880,7 +9696,7 @@ async function awaitWithdrawalPayouts(options) {
     const candidates = /* @__PURE__ */ new Map();
     const toDate = (/* @__PURE__ */ new Date()).toISOString();
     const fromDate = new Date(options.submittedAt - 5e3).toISOString();
-    const cursors = /* @__PURE__ */ new Set();
+    const cursors2 = /* @__PURE__ */ new Set();
     let cursor;
     for (let pageNumber = 0; pageNumber < 10; pageNumber++) {
       assertActive();
@@ -8906,8 +9722,8 @@ async function awaitWithdrawalPayouts(options) {
         const confirmed = inspected.flatMap((value) => value.status === "fulfilled" && value.value.transfer === "confirmed" && value.value.delivery === "confirmed" && (rawAmount(value.value.blockNumber) ?? 0n) > options.baselineBlock ? [value.value] : []);
         return confirmed.length === 1 ? confirmed[0] : void 0;
       }
-      if (!page.nextCursor || cursors.has(page.nextCursor)) return;
-      cursors.add(page.nextCursor);
+      if (!page.nextCursor || cursors2.has(page.nextCursor)) return;
+      cursors2.add(page.nextCursor);
       cursor = page.nextCursor;
     }
   };
@@ -9052,8 +9868,8 @@ function verifiedFee(payout) {
 }
 
 // src/lib/swap/swap.permit.ts
-var import_viem17 = require("viem");
-var PERMIT_ABI = (0, import_viem17.parseAbi)([
+var import_viem19 = require("viem");
+var PERMIT_ABI = (0, import_viem19.parseAbi)([
   "function nonces(address owner) view returns (uint256)",
   "function name() view returns (string)",
   "function version() view returns (string)",
@@ -9080,7 +9896,7 @@ async function tryRead(read2) {
 function matchDomain(name, versions, chainId, token, onChainSeparator) {
   for (const version of versions) {
     const domain = { name, version, chainId, verifyingContract: token };
-    if ((0, import_viem17.domainSeparator)({ domain }) === onChainSeparator) return domain;
+    if ((0, import_viem19.domainSeparator)({ domain }) === onChainSeparator) return domain;
   }
   return null;
 }
@@ -9133,9 +9949,9 @@ async function buildErc2612Permit(reads, input) {
     primaryType: "Permit",
     message: { owner, spender, value, nonce, deadline }
   });
-  const { r, s, v, yParity } = (0, import_viem17.parseSignature)(signature);
+  const { r, s, v, yParity } = (0, import_viem19.parseSignature)(signature);
   const recoveryV = v ?? BigInt(yParity + 27);
-  return (0, import_viem17.encodeAbiParameters)(
+  return (0, import_viem19.encodeAbiParameters)(
     [
       { type: "address" },
       { type: "address" },
@@ -9226,12 +10042,12 @@ function listWithdrawSwaps(now = Date.now(), includeDismissed = false) {
   if (!store) return [];
   const out = [];
   try {
-    const keys = [];
+    const keys2 = [];
     for (let i = 0; i < store.length; i++) {
       const key2 = store.key(i);
-      if (key2?.startsWith(`${KEY_PREFIX5}.`)) keys.push(key2);
+      if (key2?.startsWith(`${KEY_PREFIX5}.`)) keys2.push(key2);
     }
-    for (const key2 of keys) {
+    for (const key2 of keys2) {
       const raw2 = store.getItem(key2);
       if (!raw2) continue;
       try {
@@ -9291,12 +10107,12 @@ function listPendingDeposits(now = Date.now()) {
   if (!store) return [];
   const out = [];
   try {
-    const keys = [];
+    const keys2 = [];
     for (let i = 0; i < store.length; i++) {
       const key2 = store.key(i);
-      if (key2?.startsWith(`${KEY_PREFIX6}.`)) keys.push(key2);
+      if (key2?.startsWith(`${KEY_PREFIX6}.`)) keys2.push(key2);
     }
-    for (const key2 of keys) {
+    for (const key2 of keys2) {
       const raw2 = store.getItem(key2);
       if (!raw2) continue;
       try {
@@ -9317,6 +10133,7 @@ function listPendingDeposits(now = Date.now()) {
 }
 
 // src/lib/health-report.ts
+init_errors();
 var ROUTING_API_BASE_URL3 = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function reportAgentFailure(apiKey, agentType, errorCode, baseUrl = ROUTING_API_BASE_URL3) {
   try {
@@ -9350,7 +10167,7 @@ async function withFailureReporting(apiKey, agentType, fn, baseUrl) {
 }
 
 // src/lib/helpers/withdraw-helper.ts
-var import_viem18 = require("viem");
+var import_viem20 = require("viem");
 function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decimals) {
   return agents.map((agent) => {
     let invalidBalance = false;
@@ -9360,7 +10177,7 @@ function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decima
         return 0n;
       }
       const [whole, fraction] = value.split(".");
-      return raw2 ? BigInt(value) : (0, import_viem18.parseUnits)(fraction === void 0 ? whole : `${whole}.${fraction.slice(0, decimals)}`, decimals);
+      return raw2 ? BigInt(value) : (0, import_viem20.parseUnits)(fraction === void 0 ? whole : `${whole}.${fraction.slice(0, decimals)}`, decimals);
     };
     const agentBalance = aggregated[agent.id];
     const tokenBalance = agentBalance?.tokens.find(
@@ -9569,7 +10386,7 @@ function aggregateDailyEarnings(series, tokenSymbol) {
   }
   return [...byAsset.entries()].map(([asset, components]) => {
     const dates = [...new Set(components.flatMap((points2) => points2.map((point) => point.date)))].sort();
-    const cursors = components.map((points2) => ({
+    const cursors2 = components.map((points2) => ({
       index: 0,
       // Providers can have different lifetime/window offsets and start dates.
       // Remove each opening reading before combining their earned amounts.
@@ -9579,7 +10396,7 @@ function aggregateDailyEarnings(series, tokenSymbol) {
     const points = dates.map((date) => {
       let amount = 0;
       components.forEach((component, index) => {
-        const cursor = cursors[index];
+        const cursor = cursors2[index];
         while (cursor.index < component.length && component[cursor.index].date <= date) {
           cursor.current = component[cursor.index++].amount;
         }
@@ -9592,13 +10409,314 @@ function aggregateDailyEarnings(series, tokenSymbol) {
 }
 
 // src/client.ts
-var import_viem21 = require("viem");
+var import_viem24 = require("viem");
 var import_chains6 = require("viem/chains");
 
+// src/lib/sponsored-token-deposit.ts
+init_errors();
+
+// src/lib/token-batch-execution.ts
+var import_viem21 = require("viem");
+init_errors();
+init_token_batch_family();
+async function executeTokenBatch(input, initial) {
+  let body = initial, family, ended = false;
+  const deadlineAt = Date.now() + 9e4, controller = new AbortController();
+  let timer;
+  const pending2 = () => new OwneyError(
+    "DEPOSIT_IN_PROGRESS",
+    "Deposit is awaiting confirmation. Its transaction is still being checked.",
+    {
+      sponsorPending: true,
+      phase: body.serializedTransaction ? "deposit" : "approval",
+      txHash: body.serializedTransaction ? (0, import_viem21.keccak256)(body.serializedTransaction) : body.serializedPermitTransaction ? (0, import_viem21.keccak256)(body.serializedPermitTransaction) : void 0,
+      notSubmitted: false,
+      safeToFallback: false
+    }
+  );
+  const assertCurrent = () => {
+    if (ended || Date.now() >= deadlineAt) throw pending2();
+    input.assertCurrent?.();
+  };
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      ended = true;
+      controller.abort();
+      reject(pending2());
+    }, 9e4);
+  });
+  const bounded2 = async (work) => {
+    const value = await Promise.race([work, timeout]);
+    assertCurrent();
+    return value;
+  };
+  const post = () => bounded2(
+    postSponsorBatchTransfer({
+      apiKey: input.apiKey,
+      baseUrl: input.baseUrl,
+      body,
+      signal: controller.signal
+    })
+  );
+  const replacements = { approval: 0, deposit: 0 };
+  const unavailable = /* @__PURE__ */ new Set();
+  const observedApprovals = /* @__PURE__ */ new Set();
+  const checkpointed = /* @__PURE__ */ new Set();
+  const accounted = /* @__PURE__ */ new Set();
+  const remember = async (phase, bytes, hash2, predecessorHash) => {
+    assertCurrent();
+    if ((0, import_viem21.keccak256)(bytes) !== hash2) throw pending2();
+    const tx = (0, import_viem21.parseTransaction)(bytes);
+    const next = {
+      ...body,
+      [phase === "deposit" ? "serializedTransaction" : "serializedPermitTransaction"]: bytes
+    };
+    family = await bounded2(
+      saveTokenBatchAttempt(
+        input,
+        next,
+        {
+          phase,
+          hash: hash2,
+          serializedTransaction: bytes,
+          nonce: String(tx.nonce),
+          predecessorHash,
+          preparedAt: Date.now(),
+          submissionAttempted: false
+        },
+        assertCurrent
+      )
+    );
+    body = { ...family.body, transfers: initial.transfers };
+  };
+  const reference = (hash2) => family ? {
+    authorizationId: family.authorizationId,
+    predecessorTxHash: family.attempts.find((a) => a.hash === hash2)?.predecessorHash
+  } : void 0;
+  const markSubmission = async (phase) => {
+    const hash2 = phase === "deposit" ? family?.current.deposit : family?.current.approval;
+    if (!family || !hash2) throw pending2();
+    if (phase === "deposit" && !checkpointed.has(hash2)) {
+      try {
+        await bounded2(
+          Promise.resolve(input.onBeforeSubmission?.(hash2, reference(hash2)))
+        );
+      } catch (error) {
+        if (error instanceof OwneyError && error.code === "DEPOSIT_CHECKPOINT_FAILED")
+          throw new OwneyError(error.code, error.message, {
+            ...error.details,
+            notSubmitted: !family.attempts.some(
+              (a) => a.phase === "deposit" && a.submissionAttempted
+            ),
+            safeToFallback: false
+          });
+        throw error;
+      }
+      checkpointed.add(hash2);
+    }
+    assertCurrent();
+    const attempt = family.attempts.find((a) => a.hash === hash2);
+    family = await bounded2(
+      saveTokenBatchAttempt(
+        input,
+        body,
+        { ...attempt, submissionAttempted: true },
+        assertCurrent
+      )
+    );
+    assertCurrent();
+    if (phase === "deposit")
+      try {
+        input.onSubmitted?.(hash2, reference(hash2));
+      } catch {
+      }
+    assertCurrent();
+  };
+  const observe = async () => {
+    if (!family) return;
+    const observation = await bounded2(
+      observeTokenBatchFamily({
+        scope: input,
+        family,
+        pub: input.pub,
+        deadlineAt,
+        assertCurrent
+      })
+    );
+    if (observation.status === "confirmed") {
+      const winning = family.attempts.find(
+        (a) => a.hash === observation.txHash
+      );
+      if (!accounted.has(observation.txHash)) {
+        const accounting = new AbortController();
+        const accountingTimer = setTimeout(() => accounting.abort(), 8e3);
+        void postSponsorBatchTransfer({
+          apiKey: input.apiKey,
+          baseUrl: input.baseUrl,
+          body: {
+            ...body,
+            serializedTransaction: winning.serializedTransaction
+          },
+          signal: accounting.signal
+        }).catch(() => {
+        }).finally(() => clearTimeout(accountingTimer));
+      }
+      return observation.txHash;
+    }
+    if (observation.status === "failed" || observation.status === "expired")
+      throw new OwneyError(
+        "SPONSOR_REQUEST_FAILED",
+        observation.status === "expired" ? "The deposit authorization expired without transferring funds. Start a new deposit." : "Sponsored deposit transactions reverted. Please retry.",
+        { notSubmitted: true, safeToFallback: false }
+      );
+  };
+  try {
+    assertCurrent();
+    family = await bounded2(
+      loadTokenBatchFamily(
+        input,
+        initial.serializedTransaction ? (0, import_viem21.keccak256)(initial.serializedTransaction) : initial.serializedPermitTransaction ? (0, import_viem21.keccak256)(initial.serializedPermitTransaction) : void 0
+      )
+    );
+    if (family) body = { ...family.body, transfers: initial.transfers };
+    else
+      tokenBatchWrite(
+        tokenBatchKey(input),
+        JSON.stringify(tokenBatchStoredBody(body))
+      );
+    if (family) {
+      const winner = await observe();
+      if (winner) return winner;
+    }
+    if (family)
+      for (const attempt of family.attempts)
+        family = await bounded2(
+          saveTokenBatchAttempt(input, body, attempt, assertCurrent)
+        );
+    let needsPost = true;
+    while (true) {
+      assertCurrent();
+      const winner = await observe();
+      if (winner) return winner;
+      if (needsPost) {
+        needsPost = false;
+        const signedPhase = body.serializedTransaction ? "deposit" : body.serializedPermitTransaction ? "approval" : void 0;
+        if (signedPhase) await markSubmission(signedPhase);
+        let result;
+        try {
+          result = await post();
+        } catch (error) {
+          assertCurrent();
+          if (!family) {
+            tokenBatchClear(
+              tokenBatchKey(input),
+              JSON.stringify(tokenBatchStoredBody(body))
+            );
+            throw error;
+          }
+        }
+        if (result?.serializedPermitTransaction && !body.serializedPermitTransaction) {
+          if (!result.permitTxHash) throw pending2();
+          await remember(
+            "approval",
+            result.serializedPermitTransaction,
+            result.permitTxHash
+          );
+          needsPost = true;
+          continue;
+        }
+        if (result?.serializedTransaction && !body.serializedTransaction) {
+          await remember(
+            "deposit",
+            result.serializedTransaction,
+            result.txHash
+          );
+          needsPost = true;
+          continue;
+        }
+        if (result && !result.status && !result.serializedTransaction && !result.serializedPermitTransaction && family?.current.deposit === result.txHash)
+          accounted.add(result.txHash);
+        const winner2 = await observe();
+        if (winner2) return winner2;
+      }
+      const phase = body.serializedTransaction ? "deposit" : "approval";
+      const current = family?.current[phase];
+      if (!current) throw pending2();
+      if (phase === "approval" && !observedApprovals.has(current)) {
+        const receipt = await bounded2(
+          input.pub.getTransactionReceipt({ hash: current }).catch(() => void 0)
+        );
+        if (receipt?.status === "success" && receipt.transactionHash?.toLowerCase() === current.toLowerCase() && receipt.from?.toLowerCase() === family.relayer.toLowerCase() && receipt.to?.toLowerCase() === body.token.toLowerCase()) {
+          observedApprovals.add(current);
+          needsPost = true;
+          continue;
+        }
+      }
+      if (replacements[phase] < 2 && !unavailable.has(phase)) {
+        let recovered;
+        try {
+          recovered = await bounded2(
+            postSponsorBatchRecovery({
+              apiKey: input.apiKey,
+              baseUrl: input.baseUrl,
+              body: { ...body, phase },
+              signal: controller.signal
+            })
+          );
+        } catch {
+          assertCurrent();
+        }
+        assertCurrent();
+        if (!recovered) unavailable.add(phase);
+        else if (recovered.status === "prepared") {
+          if (recovered.predecessorHash !== current) throw pending2();
+          await remember(
+            phase,
+            recovered.serializedTransaction,
+            recovered.txHash,
+            current
+          );
+          replacements[phase]++;
+          needsPost = true;
+          continue;
+        } else if (phase === "approval" && (recovered.status === "approval-satisfied" || recovered.status === "included" && recovered.outcome === "success")) {
+          needsPost = true;
+        } else if (recovered.status === "included" && recovered.outcome === "reverted") {
+          if (phase === "approval" && !family.attempts.some((a) => a.phase === "deposit") && family.attempts.filter((a) => a.phase === "approval").length === 1) {
+            finishTokenBatchFamily(input, family, {
+              kind: "failed",
+              blockNumber: recovered.blockNumber
+            });
+            throw new OwneyError(
+              "SPONSOR_REQUEST_FAILED",
+              "Sponsored approval reverted. Please retry.",
+              { notSubmitted: true, safeToFallback: false }
+            );
+          }
+          unavailable.add(phase);
+        }
+      }
+      await bounded2(
+        new Promise(
+          (resolve) => setTimeout(
+            resolve,
+            Math.min(2e3, Math.max(0, deadlineAt - Date.now()))
+          )
+        )
+      );
+    }
+  } finally {
+    ended = true;
+    if (timer) clearTimeout(timer);
+    controller.abort();
+  }
+}
+
 // src/lib/sponsored-token-batch.ts
-var import_viem19 = require("viem");
-var memory = /* @__PURE__ */ new Map();
-var settledRecords = /* @__PURE__ */ new Map();
+init_token_batch_family();
+var import_viem22 = require("viem");
+init_errors();
+init_permit2_batch();
 var expiredRecords = /* @__PURE__ */ new Map();
 var inflight = /* @__PURE__ */ new Map();
 var planOf = (transfers) => JSON.stringify(
@@ -9607,18 +10725,7 @@ var planOf = (transfers) => JSON.stringify(
     amount: BigInt(t.amount).toString()
   }))
 );
-var pendingKey = (i) => `owney.token-batch.v1:${(0, import_viem19.keccak256)((0, import_viem19.toBytes)(i.apiKey))}:${i.baseUrl ?? "default"}:${i.chainId}:${i.owner.toLowerCase()}:${i.token.toLowerCase()}`;
-function pendingTokenBatch(i) {
-  try {
-    const saved = read(pendingKey(i));
-    if (!saved) return;
-    const body = JSON.parse(saved);
-    if (!body.serializedTransaction || body.chainId !== i.chainId || !(0, import_viem19.isAddressEqual)(body.from, i.owner) || !(0, import_viem19.isAddressEqual)(body.token, i.token) || !body.transfers?.length) return;
-    return { txHash: (0, import_viem19.keccak256)(body.serializedTransaction), transfers: body.transfers.map(({ to, amount }) => ({ to, amount })) };
-  } catch {
-    return;
-  }
-}
+var pendingKey = (i) => `owney.token-batch.v1:${(0, import_viem22.keccak256)((0, import_viem22.toBytes)(i.apiKey))}:${i.baseUrl ?? "default"}:${i.chainId}:${i.owner.toLowerCase()}:${i.token.toLowerCase()}`;
 async function releaseExpiredTokenBatch(i) {
   const key2 = pendingKey(i);
   let timer;
@@ -9627,18 +10734,18 @@ async function releaseExpiredTokenBatch(i) {
     let active2 = read(key2);
     if (active2 && i.expectedTxHash) {
       const current = JSON.parse(active2);
-      if (!current.serializedTransaction || (0, import_viem19.keccak256)(current.serializedTransaction).toLowerCase() !== i.expectedTxHash.toLowerCase())
+      if (!current.serializedTransaction || (0, import_viem22.keccak256)(current.serializedTransaction).toLowerCase() !== i.expectedTxHash.toLowerCase())
         active2 = void 0;
     }
     const archiveKey = i.expectedTxHash ? `${key2}:expired:${i.expectedTxHash.toLowerCase()}` : void 0;
     const saved = active2 ?? (archiveKey && (expiredRecords.get(archiveKey) ?? (typeof window === "undefined" ? void 0 : window.localStorage.getItem(archiveKey))));
     if (!saved) return;
     const body = JSON.parse(saved);
-    if (!body.serializedTransaction || body.chainId !== i.chainId || !(0, import_viem19.isAddressEqual)(body.from, i.owner) || !(0, import_viem19.isAddressEqual)(body.token, i.token) || !body.transfers?.length) return;
-    const txHash = (0, import_viem19.keccak256)(body.serializedTransaction);
+    if (!body.serializedTransaction || body.chainId !== i.chainId || !(0, import_viem22.isAddressEqual)(body.from, i.owner) || !(0, import_viem22.isAddressEqual)(body.token, i.token) || !body.transfers?.length) return;
+    const txHash = (0, import_viem22.keccak256)(body.serializedTransaction);
     if (i.expectedTxHash && txHash.toLowerCase() !== i.expectedTxHash.toLowerCase()) return;
-    const transaction = (0, import_viem19.parseTransaction)(body.serializedTransaction);
-    if (transaction.chainId !== i.chainId || !transaction.to || !(0, import_viem19.isAddressEqual)(transaction.to, BATCH_PERMIT2_ADDRESS) || (transaction.value ?? 0n) !== 0n || transaction.data !== (0, import_viem19.encodeFunctionData)({
+    const transaction = (0, import_viem22.parseTransaction)(body.serializedTransaction);
+    if (transaction.chainId !== i.chainId || !transaction.to || !(0, import_viem22.isAddressEqual)(transaction.to, BATCH_PERMIT2_ADDRESS) || (transaction.value ?? 0n) !== 0n || transaction.data !== (0, import_viem22.encodeFunctionData)({
       abi: PERMIT2_BATCH_ABI,
       functionName: "permitWitnessTransferFrom",
       args: batchArgs(body)
@@ -9667,8 +10774,7 @@ async function releaseExpiredTokenBatch(i) {
         }
       } catch {
       }
-      if (!persisted) settledRecords.set(key2, saved);
-      else clear(key2, body);
+      if (persisted) clear(key2, body);
     }
     return { txHash, transfers: body.transfers.map(({ to, amount }) => ({ to, amount })), blockNumber: block.number };
   };
@@ -9686,37 +10792,17 @@ async function releaseExpiredTokenBatch(i) {
     if (timer) clearTimeout(timer);
   }
 }
-function read(key2) {
-  const value = typeof window === "undefined" ? memory.get(key2) : window.localStorage.getItem(key2);
-  return value && settledRecords.get(key2) === value ? void 0 : value;
-}
-function storedBody(body) {
-  return JSON.stringify({
-    ...body,
-    transfers: body.transfers.map(({ to, amount }) => ({ to, amount }))
-  });
-}
-function save(key2, body) {
-  const value = storedBody(body);
-  if (typeof window === "undefined") memory.set(key2, value);
-  else window.localStorage.setItem(key2, value);
-  settledRecords.delete(key2);
-}
+var read = tokenBatchRead;
+var storedBody = (body) => JSON.stringify(tokenBatchStoredBody(body));
 function clear(key2, body) {
-  try {
-    if (typeof window === "undefined") memory.delete(key2);
-    else window.localStorage.removeItem(key2);
-    settledRecords.delete(key2);
-  } catch {
-    settledRecords.set(key2, storedBody(body));
-  }
+  tokenBatchClear(key2, storedBody(body));
 }
 function sponsorTokenBatch(i) {
   const key2 = pendingKey(i);
   const plan = planOf(i.transfers);
   const active2 = inflight.get(key2);
   if (active2) {
-    if (active2.plan !== plan || i.resumeTxHash && pendingTokenBatch(i)?.txHash !== i.resumeTxHash)
+    if (active2.plan !== plan)
       return Promise.reject(
         new Error(
           "A token deposit is already in progress. Wait for its result before depositing again."
@@ -9733,136 +10819,13 @@ async function execute(i, key2, plan) {
     (t) => BigInt(t.amount) <= 0n || BigInt(t.amount) >= 1n << 256n
   ) || new Set(i.transfers.map((t) => t.to.toLowerCase())).size !== i.transfers.length)
     throw new Error("Invalid token deposit shares.");
-  const send = async (initial) => {
-    let body = initial;
-    save(key2, body);
-    const rejectedPreparation = (error) => !body.serializedTransaction && error instanceof OwneyError && typeof error.details?.statusCode === "number" && error.details.statusCode >= 400 && error.details.statusCode < 500 && ![408, 429].includes(error.details.statusCode);
-    try {
-      const post = () => postSponsorBatchTransfer({ apiKey: i.apiKey, baseUrl: i.baseUrl, body });
-      const pendingError = (phase, txHash) => new OwneyError(
-        "DEPOSIT_IN_PROGRESS",
-        phase === "approval" ? "Deposit approval is awaiting confirmation. Retry the same amount to continue it." : "Deposit is awaiting confirmation. Its transaction is still being checked.",
-        { sponsorPending: true, phase, txHash, safeToFallback: false }
-      );
-      const assertReceipt = (receipt, phase) => {
-        if (receipt.status !== "success") throw new OwneyError(
-          "SPONSOR_REQUEST_FAILED",
-          `Sponsored ${phase} transaction reverted. Please retry.`,
-          { notSubmitted: true, safeToFallback: false }
-        );
-      };
-      const waitForConfirmation = async (phase, hash3) => {
-        let receipt;
-        try {
-          receipt = await i.pub.waitForTransactionReceipt({ hash: hash3, confirmations: 1, timeout: 9e4, checkReplacement: false });
-        } catch {
-          receipt = await i.pub.getTransactionReceipt({ hash: hash3 }).catch(() => void 0);
-        }
-        if (!receipt) throw pendingError(phase, hash3);
-        assertReceipt(receipt, phase);
-      };
-      const postSigned = async (phase, hash3) => {
-        try {
-          return await post();
-        } catch (error) {
-          if (rejectedPreparation(error) || error instanceof OwneyError && error.details?.notSubmitted === true) throw error;
-          await waitForConfirmation(phase, hash3);
-          return void 0;
-        }
-      };
-      if (body.erc2612Permit && !body.serializedPermitTransaction) {
-        const preparedPermit = await postSponsorBatchTransfer({
-          apiKey: i.apiKey,
-          baseUrl: i.baseUrl,
-          body
-        });
-        if (!preparedPermit.serializedPermitTransaction || !preparedPermit.permitTxHash || (0, import_viem19.keccak256)(preparedPermit.serializedPermitTransaction) !== preparedPermit.permitTxHash)
-          throw new Error(
-            "Sponsorship API did not return a valid prepared permit transaction."
-          );
-        body = {
-          ...body,
-          serializedPermitTransaction: preparedPermit.serializedPermitTransaction
-        };
-        save(key2, body);
-      }
-      if (!body.serializedTransaction) {
-        const permitHash = body.serializedPermitTransaction ? (0, import_viem19.keccak256)(body.serializedPermitTransaction) : void 0;
-        let prepared = permitHash ? await postSigned("approval", permitHash) : await post();
-        if (prepared?.status === "pending") {
-          if (!permitHash || prepared.phase !== "approval" || prepared.txHash !== permitHash)
-            throw new Error("Sponsorship approval does not match the pending transaction.");
-          await waitForConfirmation("approval", permitHash);
-          prepared = void 0;
-        }
-        if (!prepared) prepared = await post();
-        if (prepared.status === "pending" && permitHash && prepared.phase === "approval" && prepared.txHash === permitHash)
-          throw pendingError("approval", permitHash);
-        if (!prepared.serializedTransaction || (0, import_viem19.keccak256)(prepared.serializedTransaction) !== prepared.txHash)
-          throw new Error(
-            "Sponsorship API did not return a valid prepared transaction."
-          );
-        body = {
-          ...body,
-          serializedTransaction: prepared.serializedTransaction
-        };
-        save(key2, body);
-      }
-      await i.onBeforeSubmission?.((0, import_viem19.keccak256)(body.serializedTransaction));
-      try {
-        i.onSubmitted?.((0, import_viem19.keccak256)(body.serializedTransaction));
-      } catch {
-      }
-      const hash2 = (0, import_viem19.keccak256)(body.serializedTransaction);
-      const existing = await i.pub.getTransactionReceipt({ hash: hash2 }).catch(() => void 0);
-      if (existing) {
-        assertReceipt(existing, "deposit");
-        void post().catch(() => void 0);
-        clear(key2, body);
-        return hash2;
-      }
-      let result = await postSigned("deposit", hash2);
-      if (result?.status === "pending" && result.phase === "approval" && body.serializedPermitTransaction && result.txHash === (0, import_viem19.keccak256)(body.serializedPermitTransaction)) {
-        await waitForConfirmation("approval", result.txHash);
-        result = await postSigned("deposit", hash2);
-        if (result?.status === "pending" && result.phase === "approval" && result.txHash === (0, import_viem19.keccak256)(body.serializedPermitTransaction)) throw pendingError("approval", result.txHash);
-      }
-      if (result) {
-        if (result.txHash !== hash2 || result.status === "pending" && result.phase !== "deposit")
-          throw new Error("Sponsorship receipt does not match the pending transaction.");
-        if (result.status === "pending") await waitForConfirmation("deposit", hash2);
-      }
-      if (!result || result.status === "pending") void post().catch(() => void 0);
-      clear(key2, body);
-      return hash2;
-    } catch (error) {
-      if (initial.serializedTransaction && error instanceof OwneyError && error.code === "DEPOSIT_CHECKPOINT_FAILED") {
-        throw new OwneyError(
-          error.code,
-          "Could not save recovery of the existing deposit.",
-          { ...error.details, notSubmitted: false, safeToFallback: false }
-        );
-      }
-      if (!body.serializedTransaction && !body.serializedPermitTransaction || rejectedPreparation(error) || error instanceof OwneyError && error.details?.notSubmitted === true)
-        clear(key2, body);
-      throw error;
-    }
-  };
-  const saved = read(key2);
-  if (i.resumeTxHash && pendingTokenBatch(i)?.txHash !== i.resumeTxHash)
-    throw new OwneyError("DEPOSIT_IN_PROGRESS", "The saved deposit changed. Check its status before depositing again.");
+  const send = (body) => executeTokenBatch(i, body);
+  const family = await loadTokenBatchFamily(i, i.resumeTxHash);
+  const saved = family ? JSON.stringify(family.body) : read(key2);
   if (saved) {
     const previous = JSON.parse(saved);
-    if (previous.chainId !== i.chainId || !(0, import_viem19.isAddressEqual)(previous.from, i.owner) || !(0, import_viem19.isAddressEqual)(previous.token, i.token) || planOf(previous.transfers) !== plan)
-      throw new Error(
-        "Retry the previous token deposit and agent split first to reconcile its status."
-      );
-    if (await releaseExpiredTokenBatch({ ...i, expectedTxHash: previous.serializedTransaction ? (0, import_viem19.keccak256)(previous.serializedTransaction) : void 0 }))
-      throw new OwneyError(
-        "SPONSOR_REQUEST_FAILED",
-        "The deposit authorization expired without transferring funds. Start a new deposit.",
-        { notSubmitted: true, safeToFallback: false }
-      );
+    if (previous.chainId !== i.chainId || !(0, import_viem22.isAddressEqual)(previous.from, i.owner) || !(0, import_viem22.isAddressEqual)(previous.token, i.token) || planOf(previous.transfers) !== plan)
+      throw new OwneyError("DEPOSIT_IN_PROGRESS", "Retry the previous token deposit and agent split first to reconcile its status.");
     i.onApproved?.();
     return send({ ...previous, transfers: i.transfers });
   }
@@ -9968,8 +10931,9 @@ function makeSponsoredTokenCallback(deps) {
       pub,
       wallet,
       onApproved: deps.onApproved,
-      onSubmitted: (hash2) => deps.onSubmitted?.(hash2, transfers),
-      onBeforeSubmission: (hash2) => deps.onBeforeSubmission?.(hash2, transfers),
+      onSubmitted: (hash2, reference) => deps.onSubmitted?.(hash2, transfers, reference),
+      onBeforeSubmission: (hash2, reference) => deps.onBeforeSubmission?.(hash2, transfers, reference),
+      assertCurrent: deps.assertCurrent,
       resumeTxHash: deps.resumeTxHash
     });
   };
@@ -9981,6 +10945,7 @@ function makeSponsoredTokenCallback(deps) {
 }
 
 // src/lib/agent-deposit-batch.ts
+init_errors();
 function deferred() {
   let resolve, reject;
   const promise = new Promise((yes, no) => {
@@ -10028,10 +10993,10 @@ async function runAgentDepositBatch(chainId, legs, transfer) {
     }
     const txHash = await transfer(chainId, transfers);
     funding.resolve(txHash);
-    const settled = await Promise.allSettled(tasks);
+    const settled2 = await Promise.allSettled(tasks);
     const agentResults = {};
     const failures = [];
-    for (const [index, result] of settled.entries()) {
+    for (const [index, result] of settled2.entries()) {
       if (result.status === "fulfilled")
         agentResults[legs[index].id] = result.value;
       else failures.push(legs[index].id);
@@ -10056,7 +11021,8 @@ async function runAgentDepositBatch(chainId, legs, transfer) {
 }
 
 // src/lib/sponsored-calls-deposit.ts
-var import_viem20 = require("viem");
+var import_viem23 = require("viem");
+init_errors();
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -10064,7 +11030,7 @@ async function paymasterSupported(provider, owner, chainId) {
     method: "wallet_getCapabilities",
     params: [owner]
   });
-  const forChain = caps?.[(0, import_viem20.toHex)(chainId)] ?? caps?.[String(chainId)];
+  const forChain = caps?.[(0, import_viem23.toHex)(chainId)] ?? caps?.[String(chainId)];
   return Boolean(forChain?.paymasterService?.supported);
 }
 function makeSponsoredCallsCallback(deps) {
@@ -10101,8 +11067,8 @@ function makeSponsoredCallsCallback(deps) {
     const calls = transfers.map((transfer) => ({
       to: token,
       value: "0x0",
-      data: (0, import_viem20.encodeFunctionData)({
-        abi: import_viem20.erc20Abi,
+      data: (0, import_viem23.encodeFunctionData)({
+        abi: import_viem23.erc20Abi,
         functionName: "transfer",
         args: [transfer.to, BigInt(transfer.amount)]
       })
@@ -10134,7 +11100,7 @@ function makeSponsoredCallsCallback(deps) {
       url.searchParams.append("owneyIntent", intent);
       paymasterUrl = url.toString();
     }
-    const requestedId = (0, import_viem20.toHex)(globalThis.crypto.getRandomValues(new Uint8Array(32)));
+    const requestedId = (0, import_viem23.toHex)(globalThis.crypto.getRandomValues(new Uint8Array(32)));
     const progress = (id, transfer) => {
       try {
         deps.onCallsProgress?.(id, transfers, transfer);
@@ -10152,7 +11118,7 @@ function makeSponsoredCallsCallback(deps) {
             version: "2.0.0",
             id: requestedId,
             from: deps.ownerAddress,
-            chainId: (0, import_viem20.toHex)(chainId),
+            chainId: (0, import_viem23.toHex)(chainId),
             atomicRequired: transfers.length > 1,
             calls,
             capabilities: {
@@ -10306,6 +11272,7 @@ var OwneySDK = class {
   paymasterServiceUrl;
   cachedSponsoredCallsCallbacks = /* @__PURE__ */ new Map();
   agentReads = new AgentReads();
+  depositFamilyReads = /* @__PURE__ */ new Map();
   recoveredFundingReads = /* @__PURE__ */ new Set();
   fundingBalanceChecks = /* @__PURE__ */ new WeakMap();
   activationChecks = /* @__PURE__ */ new Map();
@@ -10384,17 +11351,17 @@ var OwneySDK = class {
   }
   disconnectAgents() {
     if (this.disconnectingAgents) return this.disconnectingAgents;
-    const pending = Promise.allSettled([...this.agents.values()].map(async (agent) => agent.disconnect())).then((results) => {
+    const pending2 = Promise.allSettled([...this.agents.values()].map(async (agent) => agent.disconnect())).then((results) => {
       const failure = results.find((result) => result.status === "rejected");
       if (failure?.status === "rejected") throw failure.reason;
     });
-    this.disconnectingAgents = pending;
-    void pending.then(() => {
-      if (this.disconnectingAgents === pending) this.disconnectingAgents = null;
+    this.disconnectingAgents = pending2;
+    void pending2.then(() => {
+      if (this.disconnectingAgents === pending2) this.disconnectingAgents = null;
     }, () => {
-      if (this.disconnectingAgents === pending) this.disconnectingAgents = null;
+      if (this.disconnectingAgents === pending2) this.disconnectingAgents = null;
     });
-    return pending;
+    return pending2;
   }
   isAgentDisabled(agentId) {
     return this.disabledAgents.has(agentId);
@@ -10441,11 +11408,13 @@ var OwneySDK = class {
     return createPaidRpcClient(VIEM_CHAIN2[chainId], this.rpcUrls);
   }
   /** Builds the default USDC batch callback for the connected wallet. */
-  getDefaultSponsoredCallback(onApproved, onSubmitted, resumeTxHash, onBeforeSubmission) {
-    if (!onApproved && !onSubmitted && !resumeTxHash && !onBeforeSubmission && this.cachedSponsoredCallback)
+  getDefaultSponsoredCallback(onApproved, onSubmitted, resumeTxHash, onBeforeSubmission, assertSubmissionCurrent) {
+    if (!onApproved && !onSubmitted && !resumeTxHash && !onBeforeSubmission && !assertSubmissionCurrent && this.cachedSponsoredCallback)
       return this.cachedSponsoredCallback;
     const provider = this.requireConnectedProvider();
-    const owner = this.state.walletAddress;
+    const connection = this.requireState();
+    const owner = connection.walletAddress;
+    const connectedChain = connection.chainId;
     const callback = makeSponsoredTokenCallback({
       apiKey: this.apiKey,
       baseUrl: this.routingApiBaseUrl,
@@ -10454,22 +11423,26 @@ var OwneySDK = class {
       onSubmitted,
       onBeforeSubmission,
       resumeTxHash,
+      assertCurrent: () => {
+        assertSubmissionCurrent?.();
+        if (!this.state || this.state !== connection || this.state.chainId !== connectedChain || this.state.provider !== provider || this.state.walletAddress.toLowerCase() !== owner.toLowerCase()) throw new OwneyError("NOT_CONNECTED", "Wallet changed before deposit submission.");
+      },
       tokenAddressByChain: SPONSORED_USDC_BY_CHAIN,
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
       // runtime, but the two share a name TS treats as unrelated.
       getPublicClient: (cid) => this.getPaidRpcClient(cid),
-      getWalletChainClient: (cid) => (0, import_viem21.createPublicClient)({
+      getWalletChainClient: (cid) => (0, import_viem24.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem21.custom)(provider)
+        transport: (0, import_viem24.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem21.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem24.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem21.custom)(provider)
+        transport: (0, import_viem24.custom)(provider)
       })
     });
-    if (!onApproved && !onSubmitted && !resumeTxHash && !onBeforeSubmission) this.cachedSponsoredCallback = callback;
+    if (!onApproved && !onSubmitted && !resumeTxHash && !onBeforeSubmission && !assertSubmissionCurrent) this.cachedSponsoredCallback = callback;
     return callback;
   }
   /** Builds the wallet-native sponsored calls callback for compatible paymasters. */
@@ -10498,11 +11471,13 @@ var OwneySDK = class {
    * Mirrors `getDefaultSponsoredCallback()` but signs a Permit2
    * single-use batch authorization instead of an EIP-3009 authorization.
    */
-  getDefaultWethSponsoredCallback(onApproved, onSubmitted, resumeTxHash, onBeforeSubmission) {
-    if (!onApproved && !onSubmitted && !resumeTxHash && !onBeforeSubmission && this.cachedWethSponsoredCallback)
+  getDefaultWethSponsoredCallback(onApproved, onSubmitted, resumeTxHash, onBeforeSubmission, assertSubmissionCurrent) {
+    if (!onApproved && !onSubmitted && !resumeTxHash && !onBeforeSubmission && !assertSubmissionCurrent && this.cachedWethSponsoredCallback)
       return this.cachedWethSponsoredCallback;
     const provider = this.requireConnectedProvider();
-    const owner = this.state.walletAddress;
+    const connection = this.requireState();
+    const owner = connection.walletAddress;
+    const connectedChain = connection.chainId;
     const callback = makeSponsoredTokenCallback({
       apiKey: this.apiKey,
       baseUrl: this.routingApiBaseUrl,
@@ -10511,22 +11486,26 @@ var OwneySDK = class {
       onSubmitted,
       onBeforeSubmission,
       resumeTxHash,
+      assertCurrent: () => {
+        assertSubmissionCurrent?.();
+        if (!this.state || this.state !== connection || this.state.chainId !== connectedChain || this.state.provider !== provider || this.state.walletAddress.toLowerCase() !== owner.toLowerCase()) throw new OwneyError("NOT_CONNECTED", "Wallet changed before deposit submission.");
+      },
       tokenAddressByChain: SPONSORED_WETH_BY_CHAIN,
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
       // runtime, but the two share a name TS treats as unrelated.
       getPublicClient: (cid) => this.getPaidRpcClient(cid),
-      getWalletChainClient: (cid) => (0, import_viem21.createPublicClient)({
+      getWalletChainClient: (cid) => (0, import_viem24.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem21.custom)(provider)
+        transport: (0, import_viem24.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem21.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem24.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem21.custom)(provider)
+        transport: (0, import_viem24.custom)(provider)
       })
     });
-    if (!onApproved && !onSubmitted && !resumeTxHash && !onBeforeSubmission) this.cachedWethSponsoredCallback = callback;
+    if (!onApproved && !onSubmitted && !resumeTxHash && !onBeforeSubmission && !assertSubmissionCurrent) this.cachedWethSponsoredCallback = callback;
     return callback;
   }
   getAgent(agentId) {
@@ -10850,10 +11829,10 @@ var OwneySDK = class {
       }
       notifyFunding(options.onProgress, evidence);
     } : void 0;
-    const onSubmitted = onProgress ? (hash2, destinations) => {
+    const onSubmitted = onProgress ? (hash2, destinations, depositAuthorization) => {
       for (const destination of destinations) {
         const evidence = prepared.get(destination.to.toLowerCase());
-        if (evidence) notifyFunding(onProgress, { ...evidence, txHash: hash2, transfer: "pending" });
+        if (evidence) notifyFunding(onProgress, { ...evidence, txHash: hash2, ...depositAuthorization ? { depositAuthorization } : {}, transfer: "pending" });
       }
     } : void 0;
     const onCallsProgress = onProgress ? (callsId, destinations, transfer) => {
@@ -10895,7 +11874,7 @@ var OwneySDK = class {
       });
       await checkpoint2(evidence);
     } : void 0;
-    const checkpointHash = checkpointDestinations ? (hash2, destinations) => checkpointDestinations(destinations, { txHash: hash2 }) : void 0;
+    const checkpointHash = checkpointDestinations ? (hash2, destinations, depositAuthorization) => checkpointDestinations(destinations, { txHash: hash2, depositAuthorization }) : void 0;
     const checkpointCalls = checkpointDestinations ? (id, destinations) => checkpointDestinations(destinations, { callsId: id }) : void 0;
     const checkpointPaid = checkpoint2 ? (evidence) => checkpoint2([evidence]) : void 0;
     const customCallback = depositCallback && checkpointDestinations ? makeVerificationAwareDepositCallback(async (to, cid, value, verification) => {
@@ -10905,19 +11884,20 @@ var OwneySDK = class {
     }) : depositCallback;
     if (options.resumeTxHash && (depositCallback || this.paymasterServiceUrl || !/^0x[\da-f]{64}$/i.test(options.resumeTxHash)))
       throw new OwneyError("DEPOSIT_IN_PROGRESS", "This deposit cannot resume the saved relayer transaction.");
-    const effectiveCallback = customCallback ?? (this.paymasterServiceUrl ? this.getDefaultSponsoredCallsCallback(asset, onApproved, onSubmitted, onCallsProgress, checkpointCalls) : asset === "WETH" ? this.getDefaultWethSponsoredCallback(onApproved, onSubmitted, options.resumeTxHash, checkpointHash) : this.getDefaultSponsoredCallback(onApproved, onSubmitted, options.resumeTxHash, checkpointHash));
+    const effectiveCallback = customCallback ?? (this.paymasterServiceUrl ? this.getDefaultSponsoredCallsCallback(asset, onApproved, onSubmitted, onCallsProgress, checkpointCalls) : asset === "WETH" ? this.getDefaultWethSponsoredCallback(onApproved, onSubmitted, options.resumeTxHash, checkpointHash, options.assertSubmissionCurrent) : this.getDefaultSponsoredCallback(onApproved, onSubmitted, options.resumeTxHash, checkpointHash, options.assertSubmissionCurrent));
     try {
       if (options.resumeTxHash) {
         const token = SupportedAssets.find((value) => value.chainId === chainId && value.symbol === asset);
-        const pending = token && pendingTokenBatch({
+        const family = token && await loadTokenBatchFamily({
           apiKey: this.apiKey,
           baseUrl: this.routingApiBaseUrl,
           owner: state.walletAddress,
           chainId,
           token: token.address
-        });
+        }, options.resumeTxHash);
+        const pending2 = family && { transfers: family.body.transfers };
         const invalid2 = () => new OwneyError("DEPOSIT_IN_PROGRESS", "The saved deposit does not match this request. Check its status before depositing again.");
-        if (!pending || pending.txHash.toLowerCase() !== options.resumeTxHash.toLowerCase() || pending.transfers.some((transfer) => !/^\d+$/.test(transfer.amount) || BigInt(transfer.amount) <= 0n) || pending.transfers.reduce((sum, transfer) => sum + BigInt(transfer.amount), 0n) !== BigInt(amount)) throw invalid2();
+        if (!pending2 || pending2.transfers.some((transfer) => !/^\d+$/.test(transfer.amount) || BigInt(transfer.amount) <= 0n) || pending2.transfers.reduce((sum, transfer) => sum + BigInt(transfer.amount), 0n) !== BigInt(amount)) throw invalid2();
         const candidates = agentId ? [this.getAgent(agentId)] : this.getEligibleAgents(chainId, asset);
         const wallets = await Promise.all(candidates.map(async (agent) => {
           this.validateAssetSupport(agent, chainId, asset);
@@ -10927,7 +11907,7 @@ var OwneySDK = class {
         if (this.state !== state || this.state.chainId !== chainId)
           throw new OwneyError("NOT_CONNECTED", "Wallet changed while recovering the deposit.");
         const usedAgents = /* @__PURE__ */ new Set();
-        const legs = pending.transfers.map((transfer) => {
+        const legs = pending2.transfers.map((transfer) => {
           const matches = wallets.filter((value) => value.wallet?.toLowerCase() === transfer.to.toLowerCase());
           if (matches.length !== 1 || usedAgents.has(matches[0].agent.id)) throw invalid2();
           const { agent } = matches[0];
@@ -11376,8 +12356,46 @@ var OwneySDK = class {
     if (!token) throw new OwneyError("CHAIN_UNSUPPORTED", "Unsupported funding asset.");
     const rpc2 = this.getPaidRpcClient(chainId);
     let receipt;
+    if (direction === "deposit" && !evidence.callsId && !evidence.userOpHash) {
+      const scope = {
+        apiKey: this.apiKey,
+        baseUrl: this.routingApiBaseUrl,
+        owner: state.walletAddress,
+        chainId,
+        token: token.address
+      };
+      const family = await loadTokenBatchFamily(scope, evidence.txHash, !evidence.depositAuthorization);
+      assertCurrent();
+      if (family) {
+        if (evidence.depositAuthorization && evidence.depositAuthorization.authorizationId !== family.authorizationId || !family.body.transfers.some((t) => t.to.toLowerCase() === agentWallet.toLowerCase() && t.amount === evidence.intendedAmount))
+          throw new OwneyError("DEPOSIT_IN_PROGRESS", "Deposit evidence does not match its signed authorization.");
+        const familyKey = `${tokenBatchKey(scope)}:${family.authorizationId}`;
+        let reading = this.depositFamilyReads.get(familyKey);
+        if (!reading) {
+          reading = observeTokenBatchFamily({ scope, family, pub: rpc2, deadlineAt: Date.now() + 8e3, assertCurrent }).finally(() => this.depositFamilyReads.delete(familyKey));
+          this.depositFamilyReads.set(familyKey, reading);
+        }
+        const result = await reading;
+        assertCurrent();
+        evidence = { ...evidence, depositAuthorization: { authorizationId: family.authorizationId } };
+        if (result.status === "confirmed") {
+          receipt = result.receipt;
+          evidence = { ...evidence, txHash: result.txHash };
+        } else if (result.status === "expired" || result.status === "failed")
+          return {
+            ...evidence,
+            agentWallet,
+            transfer: "failed",
+            delivery: "not-applicable",
+            registration: "not-applicable",
+            confirmedAmount: "0",
+            blockNumber: (result.status === "expired" ? result.blockNumber : result.receipts.reduce((n, r) => r.blockNumber > n ? r.blockNumber : n, 0n)).toString()
+          };
+        else return { ...evidence, agentWallet, transfer: "unknown", delivery: "not-applicable" };
+      }
+    }
     try {
-      receipt = await rpc2.getTransactionReceipt({ hash: evidence.txHash });
+      receipt ??= await rpc2.getTransactionReceipt({ hash: evidence.txHash });
     } catch (error) {
       if (direction === "deposit") {
         const expired = await releaseExpiredTokenBatch({
@@ -11497,29 +12515,65 @@ var OwneySDK = class {
   /** Whether a foreground deposit can resume the same signed batch, never a
    * fresh authorization. The batch rail independently rechecks the exact plan. */
   async canResumePendingDeposit(evidences, amount) {
-    if (this.paymasterServiceUrl || !evidences.length || !/^\d+$/.test(amount)) return false;
-    const first = evidences[0];
-    const { state, chainId, assertCurrent } = this.captureReadScope(first.chainId);
-    const token = SupportedAssets.find((value) => value.chainId === chainId && value.symbol === first.token);
-    if (!token) return false;
-    const pending = pendingTokenBatch({
-      apiKey: this.apiKey,
-      baseUrl: this.routingApiBaseUrl,
-      owner: state.walletAddress,
-      chainId,
-      token: token.address
-    });
-    if (!pending || pending.transfers.length !== evidences.length || pending.transfers.reduce((sum, transfer) => sum + BigInt(transfer.amount), 0n).toString() !== amount) return false;
-    const destinations = /* @__PURE__ */ new Set();
-    for (const evidence of evidences) {
-      if (evidence.chainId !== chainId || evidence.token !== first.token || evidence.walletAddress.toLowerCase() !== state.walletAddress.toLowerCase() || evidence.callsId || evidence.userOpHash || evidence.txHash?.toLowerCase() !== pending.txHash.toLowerCase()) return false;
-      const agent = this.getAgent(evidence.agentId);
-      const wallet = agent.getFundingWallet ? await agent.getFundingWallet(state, chainId, evidence.token) : (await agent.getUserProfile(state, chainId)).smartWallet;
-      if (!wallet || destinations.has(wallet.toLowerCase()) || !pending.transfers.some((transfer) => transfer.to.toLowerCase() === wallet.toLowerCase() && transfer.amount === evidence.intendedAmount)) return false;
-      destinations.add(wallet.toLowerCase());
+    try {
+      if (this.paymasterServiceUrl || !evidences.length || !/^\d+$/.test(amount)) return false;
+      const first = evidences[0];
+      if (!first.txHash) return false;
+      const { state, chainId, assertCurrent } = this.captureReadScope(first.chainId);
+      const token = SupportedAssets.find((value) => value.chainId === chainId && value.symbol === first.token);
+      if (!token) return false;
+      const family = await loadTokenBatchFamily({
+        apiKey: this.apiKey,
+        baseUrl: this.routingApiBaseUrl,
+        owner: state.walletAddress,
+        chainId,
+        token: token.address
+      }, first.txHash);
+      const transfers = family?.body.transfers;
+      if (!family || !transfers || transfers.length !== evidences.length || transfers.reduce((n, t) => n + BigInt(t.amount), 0n).toString() !== amount) return false;
+      const destinations = /* @__PURE__ */ new Set();
+      for (const e of evidences) {
+        if (e.chainId !== chainId || e.token !== first.token || e.walletAddress.toLowerCase() !== state.walletAddress.toLowerCase() || e.callsId || e.userOpHash || !family.attempts.some((a) => a.phase === "deposit" && a.hash.toLowerCase() === e.txHash?.toLowerCase()) || e.depositAuthorization && e.depositAuthorization.authorizationId !== family.authorizationId) return false;
+        const agent = this.getAgent(e.agentId);
+        const wallet = agent.getFundingWallet ? await agent.getFundingWallet(state, chainId, e.token) : (await agent.getUserProfile(state, chainId)).smartWallet;
+        assertCurrent();
+        if (!wallet || destinations.has(wallet.toLowerCase()) || e.agentWallet && e.agentWallet.toLowerCase() !== wallet.toLowerCase() || !transfers.some((t) => t.to.toLowerCase() === wallet.toLowerCase() && t.amount === e.intendedAmount)) return false;
+        destinations.add(wallet.toLowerCase());
+      }
+      assertCurrent();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Validate signed journal membership, never just a caller-supplied family ID. */
+  async validateDepositReplacement(previous, next) {
+    try {
+      if (!previous.length || previous.length !== next.length || previous.some((e) => e.transfer === "confirmed" || !/^\d+$/.test(e.intendedAmount))) return;
+      const amount = previous.reduce((sum, e) => sum + BigInt(e.intendedAmount), 0n).toString();
+      if (!await this.canResumePendingDeposit(previous, amount) || !await this.canResumePendingDeposit(next, amount)) return;
+      const { state, chainId, assertCurrent } = this.captureReadScope(previous[0].chainId);
+      const token = SupportedAssets.find((t) => t.chainId === chainId && t.symbol === previous[0].token);
+      const family = await loadTokenBatchFamily({
+        apiKey: this.apiKey,
+        baseUrl: this.routingApiBaseUrl,
+        owner: state.walletAddress,
+        chainId,
+        token: token.address
+      }, previous[0].txHash);
+      assertCurrent();
+      if (!family || family.terminal) return;
+      const predecessorTxHash = previous[0].txHash, replacementTxHash = next[0].txHash;
+      const replacement = family.attempts.find((a) => a.phase === "deposit" && a.hash.toLowerCase() === replacementTxHash.toLowerCase());
+      if (!replacement || replacement.predecessorHash?.toLowerCase() !== predecessorTxHash.toLowerCase()) return;
+      for (const p of previous) {
+        const matches = next.filter((n2) => n2.agentId === p.agentId), n = matches[0];
+        if (matches.length !== 1 || p.txHash?.toLowerCase() !== predecessorTxHash.toLowerCase() || n.txHash?.toLowerCase() !== replacementTxHash.toLowerCase() || p.intendedAmount !== n.intendedAmount || p.agentWallet?.toLowerCase() !== n.agentWallet?.toLowerCase() || n.depositAuthorization?.authorizationId !== family.authorizationId || n.depositAuthorization.predecessorTxHash?.toLowerCase() !== predecessorTxHash.toLowerCase()) return;
+      }
+      return { authorizationId: family.authorizationId, predecessorTxHash, replacementTxHash };
+    } catch {
+      return;
     }
-    assertCurrent();
-    return true;
   }
   /** Optional post-payout display proof; receipt verification and the provider
    * adapter must agree before attaching it to this exact balance object. */
@@ -11549,13 +12603,13 @@ var OwneySDK = class {
         metadata
       ] };
     };
-    const pending = Promise.race([read2(), new Promise((resolve) => {
+    const pending2 = Promise.race([read2(), new Promise((resolve) => {
       timer = setTimeout(() => resolve(balance), 2e3);
     })]).catch(() => balance).finally(() => {
       if (timer) clearTimeout(timer);
     });
-    checks.set(key2, pending);
-    const result = await pending;
+    checks.set(key2, pending2);
+    const result = await pending2;
     assertCurrent();
     return result;
   }
@@ -11647,11 +12701,11 @@ var OwneySDK = class {
       );
     }
     await ensureWalletOnChain(
-      (0, import_viem21.createPublicClient)({ chain: chain2, transport: (0, import_viem21.custom)(provider) }),
-      (0, import_viem21.createWalletClient)({
+      (0, import_viem24.createPublicClient)({ chain: chain2, transport: (0, import_viem24.custom)(provider) }),
+      (0, import_viem24.createWalletClient)({
         account: state.walletAddress,
         chain: chain2,
-        transport: (0, import_viem21.custom)(provider)
+        transport: (0, import_viem24.custom)(provider)
       }),
       chainId
     );
@@ -11671,19 +12725,22 @@ var OwneySDK = class {
    * quote's source token. A quote naming ETH would have all of them reading
    * the wrong asset.
    */
-  async wrapNativeSource(quote, walletAddress, onStage, direction) {
+  async wrapNativeSource(quote, walletAddress, onStage, direction, assertCurrent) {
     const wrapper = requireWrapper(quote);
     const chainId = quote.src.chainId;
     const chain2 = swapChain(chainId);
     const provider = this.requireConnectedProvider();
-    const publicClient = (0, import_viem21.createPublicClient)({
+    const publicClient = (0, import_viem24.createPublicClient)({
       chain: chain2,
       transport: swapReadTransport(chainId, this.zyfaiRpcUrls)
     });
-    const wallet = (0, import_viem21.createWalletClient)({
+    const wallet = (0, import_viem24.createWalletClient)({
       account: walletAddress,
       chain: chain2,
-      transport: (0, import_viem21.custom)(provider)
+      transport: (0, import_viem24.custom)({ request: (args) => {
+        assertCurrent?.();
+        return provider.request(args);
+      } })
     });
     onStage?.("wrapping");
     const { wrapped } = await wrapNative(
@@ -11704,6 +12761,7 @@ var OwneySDK = class {
           return fees.maxFeePerGas ?? publicClient.getGasPrice();
         },
         sendTransaction: async (tx, onSubmitted) => {
+          assertCurrent?.();
           const hash2 = await wallet.sendTransaction({
             to: tx.to,
             data: tx.data,
@@ -11790,22 +12848,22 @@ var OwneySDK = class {
     };
     const srcChain = swapChain(quote.src.chainId);
     const dstChain = swapChain(quote.dst.chainId);
-    const wallet = (0, import_viem21.createWalletClient)({
+    const wallet = (0, import_viem24.createWalletClient)({
       account: state.walletAddress,
       chain: srcChain,
       // viem can await chain/account preparation before dispatching a wallet
       // request. Recheck at the transport boundary so an expired attempt or
       // replaced session cannot send after that internal await completes.
-      transport: (0, import_viem21.custom)({ request: (args) => {
+      transport: (0, import_viem24.custom)({ request: (args) => {
         assertWallet();
         return provider.request(args);
       } }, { retryCount: 0 })
     });
-    const srcPublic = (0, import_viem21.createPublicClient)({
+    const srcPublic = (0, import_viem24.createPublicClient)({
       chain: srcChain,
       transport: swapReadTransport(quote.src.chainId, this.zyfaiRpcUrls)
     });
-    const dstPublic = (0, import_viem21.createPublicClient)({
+    const dstPublic = (0, import_viem24.createPublicClient)({
       chain: dstChain,
       transport: swapReadTransport(quote.dst.chainId, this.zyfaiRpcUrls)
     });
@@ -11822,7 +12880,7 @@ var OwneySDK = class {
         }
         return dstPublic.readContract({
           address: dst,
-          abi: import_viem21.erc20Abi,
+          abi: import_viem24.erc20Abi,
           functionName: "balanceOf",
           args: [state.walletAddress]
         });
@@ -11964,9 +13022,9 @@ var OwneySDK = class {
   async readTokenBalance(chainId, token) {
     const state = this.requireState();
     return readErc20Balance(
-      (0, import_viem21.createPublicClient)({
+      (0, import_viem24.createPublicClient)({
         chain: swapChain(chainId),
-        transport: (0, import_viem21.custom)(this.requireConnectedProvider())
+        transport: (0, import_viem24.custom)(this.requireConnectedProvider())
       }),
       token,
       state.walletAddress
@@ -11976,9 +13034,9 @@ var OwneySDK = class {
   async readTokenPermit2Allowance(chainId, token) {
     const state = this.requireState();
     return readPermit2Allowance(
-      (0, import_viem21.createPublicClient)({
+      (0, import_viem24.createPublicClient)({
         chain: swapChain(chainId),
-        transport: (0, import_viem21.custom)(this.requireConnectedProvider())
+        transport: (0, import_viem24.custom)(this.requireConnectedProvider())
       }),
       token,
       state.walletAddress
@@ -11991,13 +13049,19 @@ var OwneySDK = class {
    * Native Base/Arbitrum USDC uses sponsored ERC-2612; configured paymaster
    * wallet calls also cover approval without spending the received tokens.
    */
-  async settleSwapDepositAmount(chainId, token, symbol2, received) {
+  async settleSwapDepositAmount(chainId, token, symbol2, received, assertCurrent) {
     if (symbol2 !== "WETH" && symbol2 !== "USDC" || this.paymasterServiceUrl || supportsSponsoredErc2612(chainId, token)) {
       return received.toString();
     }
     const allowance = await this.readTokenPermit2Allowance(chainId, token);
+    assertCurrent?.();
     if (allowance < received) {
-      await this.approvePermit2(symbol2, received, chainId);
+      await this.approvePermit2(
+        symbol2,
+        received,
+        chainId,
+        ...assertCurrent ? [assertCurrent] : []
+      );
     }
     const balance = await this.readTokenBalance(chainId, token);
     return (balance < received ? balance : received).toString();
@@ -12005,9 +13069,9 @@ var OwneySDK = class {
   async walletSeesBalance(chainId, token, amount) {
     const provider = this.requireConnectedProvider();
     const state = this.requireState();
-    const pub = (0, import_viem21.createPublicClient)({
+    const pub = (0, import_viem24.createPublicClient)({
       chain: swapChain(chainId),
-      transport: (0, import_viem21.custom)(provider)
+      transport: (0, import_viem24.custom)(provider)
     });
     const { arrived } = await awaitBalanceIncrease({
       readBalance: () => pub.readContract({
@@ -12028,7 +13092,7 @@ var OwneySDK = class {
    * so the deposit half of `swapAndDeposit` can be exercised on its own.
    */
   runSwap(quote, options) {
-    return executeSwap(this.buildSwapDeps(quote), { quote, ...options });
+    return executeSwap(this.buildSwapDeps(quote, options.assertCurrent), { quote, ...options });
   }
   /**
    * The half of the swap deps that only ever talks to the routing API.
@@ -12130,7 +13194,7 @@ var OwneySDK = class {
   async resumePendingSwaps(options = {}) {
     await mapConcurrent(listWithdrawSwaps(Date.now(), true).filter((record2) => record2.txHash && record2.status === "unknown" && (!options.orderHash || options.orderHash === record2.orderHash)), async (record2) => {
       try {
-        const rpc2 = (0, import_viem21.createPublicClient)({ chain: swapChain(record2.srcChainId), transport: swapReadTransport(record2.srcChainId, this.zyfaiRpcUrls) });
+        const rpc2 = (0, import_viem24.createPublicClient)({ chain: swapChain(record2.srcChainId), transport: swapReadTransport(record2.srcChainId, this.zyfaiRpcUrls) });
         const receipt = await bounded(
           () => rpc2.getTransactionReceipt({ hash: record2.txHash }),
           8e3,
@@ -12140,10 +13204,10 @@ var OwneySDK = class {
       } catch {
       }
     });
-    const pending = listOrders().filter((order) => !isOrderObserved(order.orderHash) && (!options.orderHash || order.orderHash === options.orderHash));
+    const pending2 = listOrders().filter((order) => !isOrderObserved(order.orderHash) && (!options.orderHash || order.orderHash === options.orderHash));
     const runner = this.swapRunnerDeps();
     const sameChain = this.resumeSameChainSwaps(options);
-    const results = await mapConcurrent(pending, async (order) => {
+    const results = await mapConcurrent(pending2, async (order) => {
       try {
         await runFusionOrder(runner, {
           orderHash: order.orderHash,
@@ -12316,45 +13380,69 @@ var OwneySDK = class {
    */
   async swapAndDeposit(options) {
     const state = this.requireState();
+    options.assertCurrent?.();
+    if (options.agentId) {
+      this.validateAssetSupport(
+        this.getAgent(options.agentId),
+        options.to.chainId,
+        options.to.symbol
+      );
+    }
     const api = this.swapApi();
     const quoted = await api.quote({
       from: options.from,
       to: options.to,
       walletAddress: state.walletAddress
     });
+    options.assertCurrent?.();
     const quote = quoted.requiresOnchainOrder ? await this.wrapNativeSource(
       quoted,
       state.walletAddress,
-      options.onSwapProgress
+      options.onSwapProgress,
+      void 0,
+      options.assertCurrent
     ) : quoted;
+    options.assertCurrent?.();
     await this.ensureSwapChain(quote.src.chainId);
+    options.assertCurrent?.();
     const swap = await this.runSwap(quote, {
       walletAddress: state.walletAddress,
+      ...options.assertCurrent ? { assertCurrent: options.assertCurrent } : {},
       ...options.slippage === void 0 ? {} : { slippage: options.slippage },
       ...options.onSwapProgress ? { onStage: options.onSwapProgress } : {}
     });
     options.onSwapProgress?.("depositing");
     try {
+      options.assertCurrent?.();
       await this.ensureSwapChain(quote.dst.chainId);
+      options.assertCurrent?.();
       await this.walletSeesBalance(
         quote.dst.chainId,
         quote.dst.address,
         BigInt(swap.received)
       );
+      options.assertCurrent?.();
       const amount = await this.settleSwapDepositAmount(
         quote.dst.chainId,
         quote.dst.address,
         options.to.symbol,
-        BigInt(swap.received)
+        BigInt(swap.received),
+        options.assertCurrent
       );
+      options.assertCurrent?.();
+      await options.onBeforeDeposit?.();
+      options.assertCurrent?.();
       const deposit = await this.deposit({
         amount,
         asset: options.to.symbol,
-        ...options.agentId ? { agentId: options.agentId } : {}
+        ...options.agentId ? { agentId: options.agentId } : {},
+        ...options.onDepositProgress ? { onProgress: options.onDepositProgress } : {},
+        ...options.onBeforeDepositSubmission ? { onBeforeSubmission: options.onBeforeDepositSubmission } : {},
+        ...options.assertCurrent ? { assertSubmissionCurrent: options.assertCurrent } : {}
       });
       return { swap, deposit, deposited: amount };
     } catch (error) {
-      const pending = {
+      const pending2 = {
         id: `${quote.dst.chainId}-${options.to.symbol}-${Date.now()}`,
         received: swap.received,
         symbol: options.to.symbol,
@@ -12362,12 +13450,12 @@ var OwneySDK = class {
         ...options.agentId ? { agentId: options.agentId } : {},
         createdAt: Date.now()
       };
-      savePendingDeposit(pending);
+      savePendingDeposit(pending2);
       throw new OwneyError(
         "SWAP_DEPOSIT_PENDING",
         `The swap went through and your ${options.to.symbol} is in your wallet, but adding it to the agent didn't complete. Nothing needs swapping again.`,
         {
-          ...pending,
+          ...pending2,
           cause: error instanceof Error ? error.message : String(error),
           ...error instanceof OwneyError ? { causeCode: error.code } : {}
         }
@@ -12390,7 +13478,7 @@ var OwneySDK = class {
         "Some withdrawal results remain unknown. Check Activity and balances before continuing.",
         { reason: "WITHDRAWAL_RESULTS_UNAVAILABLE", swapSubmitted: false }
       );
-    const rpc2 = (0, import_viem21.createPublicClient)({
+    const rpc2 = (0, import_viem24.createPublicClient)({
       chain: VIEM_CHAIN2[record2.srcChainId],
       transport: swapReadTransport(record2.srcChainId, this.zyfaiRpcUrls)
     });
@@ -12423,7 +13511,7 @@ var OwneySDK = class {
         baselineBlock: BigInt(recovery.baselineBlock),
         timeoutMs: 3e4,
         assertCurrent: assertRecoveryCurrent,
-        readBalance: () => rpc2.readContract({ address: asset.address, abi: import_viem21.erc20Abi, functionName: "balanceOf", args: [state.walletAddress] }),
+        readBalance: () => rpc2.readContract({ address: asset.address, abi: import_viem24.erc20Abi, functionName: "balanceOf", args: [state.walletAddress] }),
         inspect: (value, fromHistory) => this.inspectFunding(value, "withdraw", { requireAmountMatch: fromHistory, refreshBalance: false }),
         resolve: (value) => this.resolveSponsoredWithdrawalEvidence(value, { submittedAt: recovery.submittedAt }),
         history: (value, fromDate, filters) => this.getFundingHistory(value, fromDate, filters),
@@ -12527,13 +13615,13 @@ var OwneySDK = class {
         );
       }
       const srcChain = VIEM_CHAIN2[options.from.chainId];
-      const srcPublic = (0, import_viem21.createPublicClient)({
+      const srcPublic = (0, import_viem24.createPublicClient)({
         chain: srcChain,
         transport: swapReadTransport(options.from.chainId, this.zyfaiRpcUrls)
       });
       const readWalletBalance = () => srcPublic.readContract({
         address: asset.address,
-        abi: import_viem21.erc20Abi,
+        abi: import_viem24.erc20Abi,
         functionName: "balanceOf",
         args: [state.walletAddress]
       });
@@ -12554,7 +13642,7 @@ var OwneySDK = class {
       });
       options.onSwapProgress?.("withdrawing");
       const submittedAt = saved?.recovery?.submittedAt ?? Date.now();
-      const requested = saved ? saved.recovery.requested === void 0 ? void 0 : BigInt(saved.recovery.requested) : options.amount === void 0 ? void 0 : (0, import_viem21.parseUnits)(options.amount, asset.decimals);
+      const requested = saved ? saved.recovery.requested === void 0 ? void 0 : BigInt(saved.recovery.requested) : options.amount === void 0 ? void 0 : (0, import_viem24.parseUnits)(options.amount, asset.decimals);
       confirmationDeadline = Date.now() + (options.arrivalTimeoutMs ?? 18e4);
       const attemptId = saved?.recovery?.attemptId ?? `withdraw-${globalThis.crypto.randomUUID()}`;
       record2 = saved ?? {
@@ -12879,12 +13967,12 @@ var OwneySDK = class {
     const submissionEvidence = /* @__PURE__ */ new Map();
     const pendingSubmissions = () => Object.fromEntries([...submissionEvidence].filter(([id, evidence]) => evidence.agentId === id && evidence.chainId === chainId && evidence.token === token && evidence.walletAddress.toLowerCase() === state.walletAddress.toLowerCase() && evidence.transfer !== "failed" && evidence.delivery !== "failed" && (evidence.transfer === "unknown" || evidence.txHash || evidence.userOpHash || evidence.callsId)));
     const throwUnconfirmed = (agentErrors2) => {
-      const pending = pendingSubmissions();
-      if (Object.keys(pending).length)
+      const pending2 = pendingSubmissions();
+      if (Object.keys(pending2).length)
         throw new OwneyError(
           "WITHDRAW_UNCONFIRMED",
           "The withdrawal was submitted, but its outcome could not be confirmed yet.",
-          { asset, amount, agentErrors: agentErrors2, agentFailures, pendingSubmissions: pending }
+          { asset, amount, agentErrors: agentErrors2, agentFailures, pendingSubmissions: pending2 }
         );
     };
     const submit = async (agent, requested2) => {
@@ -13045,7 +14133,7 @@ var OwneySDK = class {
       if (this.isUserRejectedWithdrawal(originalFailure)) throw originalFailure;
       if (entry.balance !== 0n && entry.agent.id !== "yieldseeker") {
         const total = aggregated.agentBalances[entry.agent.id]?.assetBalances?.find((value) => value.chainId === chainId && value.asset.toUpperCase() === token);
-        if (!total || (0, import_viem21.parseUnits)(total.amount, assetInfo.decimals) <= entry.balance) return;
+        if (!total || (0, import_viem24.parseUnits)(total.amount, assetInfo.decimals) <= entry.balance) return;
       }
       try {
         const otherAvailable = indexedAvailable - entry.balance;
@@ -13337,15 +14425,15 @@ var OwneySDK = class {
     return this.aggregateEarnings([...this.getActiveAgents().entries()], refreshAgent);
   }
   async aggregateEarnings(entries, read2) {
-    const settled = await Promise.allSettled(entries.map(([, agent]) => read2(agent)));
+    const settled2 = await Promise.allSettled(entries.map(([, agent]) => read2(agent)));
     const agentEarnings = {};
     const agentErrors = {};
     const agentRetryAt = {};
     const failures = [];
     let totalEarnings = 0;
-    for (let i = 0; i < settled.length; i++) {
+    for (let i = 0; i < settled2.length; i++) {
       const [id] = entries[i];
-      const result = settled[i];
+      const result = settled2[i];
       if (result.status === "fulfilled") {
         agentEarnings[id] = result.value;
         totalEarnings += Number(result.value.lifetimeEarnings);
@@ -13414,7 +14502,7 @@ var OwneySDK = class {
     const entries = [...this.getActiveAgents().entries()].filter(
       ([, agent]) => agent.getDailyEarnings
     );
-    const settled = await Promise.allSettled(
+    const settled2 = await Promise.allSettled(
       entries.map(
         ([, agent]) => this.readAgent(
           agent,
@@ -13424,9 +14512,9 @@ var OwneySDK = class {
         )
       )
     );
-    const series = settled.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+    const series = settled2.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
     if (entries.length && !series.length) {
-      const failure = settled.find((result) => result.status === "rejected");
+      const failure = settled2.find((result) => result.status === "rejected");
       if (failure?.status === "rejected") throw failure.reason;
     }
     return {
@@ -13649,12 +14737,12 @@ var OwneySDK = class {
     ]);
     const existing = this.activationChecks.get(key2);
     if (existing) return existing;
-    const pending = Promise.resolve().then(() => agent.ensureAutoSelectProtocols(state, chainId, asset)).finally(() => {
-      if (this.activationChecks.get(key2) === pending)
+    const pending2 = Promise.resolve().then(() => agent.ensureAutoSelectProtocols(state, chainId, asset)).finally(() => {
+      if (this.activationChecks.get(key2) === pending2)
         this.activationChecks.delete(key2);
     });
-    this.activationChecks.set(key2, pending);
-    return pending;
+    this.activationChecks.set(key2, pending2);
+    return pending2;
   }
   /**
    * User-paid approval of Permit2 on the selected token for the active chain.
@@ -13667,7 +14755,7 @@ var OwneySDK = class {
    * @param expectedChainId Chain captured by the deposit that requested approval.
    * @returns the approval transaction hash.
    */
-  async approvePermit2(asset = "WETH", requiredAmount = 0n, expectedChainId) {
+  async approvePermit2(asset = "WETH", requiredAmount = 0n, expectedChainId, assertCurrent) {
     const state = this.requireState();
     const chainId = expectedChainId ?? this.requireChainId();
     this.getEligibleAgents(chainId, asset, { excludeDisabled: true });
@@ -13679,18 +14767,22 @@ var OwneySDK = class {
       );
     }
     const provider = this.requireConnectedProvider();
-    const walletChainClient = (0, import_viem21.createPublicClient)({
+    const walletChainClient = (0, import_viem24.createPublicClient)({
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem21.custom)(provider)
+      transport: (0, import_viem24.custom)(provider)
     });
     const publicClient = this.getPaidRpcClient(chainId);
     const approvalAmount = permit2ApprovalAmount(requiredAmount);
-    const wallet = (0, import_viem21.createWalletClient)({
+    const wallet = (0, import_viem24.createWalletClient)({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem21.custom)(provider)
+      transport: (0, import_viem24.custom)({ request: (args) => {
+        assertCurrent?.();
+        return provider.request(args);
+      } })
     });
     await ensureWalletOnChain(walletChainClient, wallet, chainId);
+    assertCurrent?.();
     const hash2 = await wallet.writeContract({
       address: token,
       abi: ERC20_ALLOWANCE_ABI,
@@ -13829,10 +14921,10 @@ var OwneySDK = class {
     const agentErrors = {};
     const agentFailures = [];
     for (let i = 0; i < balanceResults.length; i++) {
-      const settled = balanceResults[i];
+      const settled2 = balanceResults[i];
       const [aid] = entries[i];
-      if (settled.status === "fulfilled") {
-        const [id, positions] = settled.value;
+      if (settled2.status === "fulfilled") {
+        const [id, positions] = settled2.value;
         const per = computeAllocationApy(positions);
         agentApy[id] = {
           totalApy: per.totalApy,
@@ -13841,7 +14933,7 @@ var OwneySDK = class {
         allPositions.push(...positions);
         successCount += 1;
       } else {
-        const reason = settled.reason;
+        const reason = settled2.reason;
         agentFailures.push(reason);
         agentErrors[aid] = reason instanceof Error ? reason.message : String(reason);
         console.error(`getAllocationApy agent "${aid}" failed:`, reason);
@@ -13863,8 +14955,11 @@ var OwneySDK = class {
   }
 };
 
+// src/index.ts
+init_errors();
+
 // src/agents/zyfai/zyfai.siwx.ts
-var import_viem22 = require("viem");
+var import_viem25 = require("viem");
 var import_siwe2 = require("siwe");
 var import_sdk2 = require("@zyfai/sdk");
 
@@ -13991,7 +15086,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new import_siwe2.SiweMessage({
-          address: (0, import_viem22.getAddress)(accountAddress),
+          address: (0, import_viem25.getAddress)(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,