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

package/dist/index.js

@@ -1,213 +1,28 @@
-// 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);
-  }
-}
-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
-import { parseAbi, hashStruct } from "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 = parseAbi([
-  "function name() view returns (string)",
-  "function version() view returns (string)",
-  "function nonces(address owner) view returns (uint256)"
-]);
-function erc2612TypedData(input) {
-  return {
-    domain: {
-      name: input.permit.tokenName,
-      version: input.permit.tokenVersion,
-      chainId: input.chainId,
-      verifyingContract: input.token
-    },
-    types: ERC2612_PERMIT_TYPES,
-    primaryType: "Permit",
-    message: {
-      owner: input.owner,
-      spender: BATCH_PERMIT2_ADDRESS,
-      value: BigInt(input.permit.value),
-      nonce: BigInt(input.permit.nonce),
-      deadline: BigInt(input.permit.deadline)
-    }
-  };
-}
-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 = 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) => ({
-      token: b.token,
-      amount: BigInt(t.amount)
-    })),
-    nonce: BigInt(b.nonce),
-    deadline: BigInt(b.deadline)
-  };
-}
-function batchTypedData(b, spender) {
-  return {
-    domain: {
-      name: "Permit2",
-      chainId: b.chainId,
-      verifyingContract: BATCH_PERMIT2_ADDRESS
-    },
-    types: PERMIT_BATCH_TYPES,
-    primaryType: "PermitBatchWitnessTransferFrom",
-    message: {
-      ...batchPermit(b),
-      spender,
-      witness: { recipients: b.transfers.map((t) => t.to) }
-    }
-  };
-}
-var BATCH_WITNESS_TYPE = "Deposit witness)Deposit(address[] recipients)TokenPermissions(address token,uint256 amount)";
-function batchWitness(b) {
-  return hashStruct({
-    types: PERMIT_BATCH_TYPES,
-    primaryType: "Deposit",
-    data: { recipients: b.transfers.map((t) => t.to) }
-  });
-}
-function batchArgs(b) {
-  return [
-    batchPermit(b),
-    b.transfers.map((t) => ({ to: t.to, requestedAmount: BigInt(t.amount) })),
-    b.from,
-    batchWitness(b),
-    BATCH_WITNESS_TYPE,
-    b.signature
-  ];
-}
+import {
+  AgentChainIncompatibleError,
+  AgentNotFoundError,
+  BATCH_PERMIT2_ADDRESS,
+  ERC2612_READ_ABI,
+  NotConnectedError,
+  OwneyError,
+  PERMIT2_BATCH_ABI,
+  batchArgs,
+  batchTypedData,
+  erc2612TypedData,
+  finishTokenBatchFamily,
+  loadTokenBatchFamily,
+  saveTokenBatchAttempt,
+  supportsSponsoredErc2612,
+  tokenBatchClear,
+  tokenBatchKey,
+  tokenBatchRead,
+  tokenBatchStoredBody,
+  tokenBatchWrite,
+  validateTokenBatchAttempt
+} from "./chunk-LUQ4H72X.js";
 
 // src/lib/funding-evidence.ts
-import { decodeEventLog, decodeFunctionData, erc20Abi, parseAbi as parseAbi2 } from "viem";
+import { decodeEventLog, decodeFunctionData, erc20Abi, parseAbi } from "viem";
 import { entryPoint06Abi, entryPoint07Abi, getUserOperationHash, toUserOperation } from "viem/account-abstraction";
 function notifyFunding(callback, evidence) {
   try {
@@ -216,9 +31,9 @@ function notifyFunding(callback, evidence) {
   } catch {
   }
 }
-var fullWithdrawalAbi = parseAbi2(["function withdrawAllAssetToUser(address recipient, address asset)"]);
-var withdrawalEventAbi = parseAbi2(["event WithdrewTokenToUser(address indexed owner, address indexed recipient, address indexed token, uint256 amount)"]);
-var accountExecutionAbi = parseAbi2([
+var fullWithdrawalAbi = parseAbi(["function withdrawAllAssetToUser(address recipient, address asset)"]);
+var withdrawalEventAbi = parseAbi(["event WithdrewTokenToUser(address indexed owner, address indexed recipient, address indexed token, uint256 amount)"]);
+var accountExecutionAbi = parseAbi([
   "function execute(address target,uint256 value,bytes data)",
   "function executeBatch((address target,uint256 value,bytes data)[] calls)"
 ]);
@@ -384,6 +199,213 @@ function inspectFundingReceipt(receipt, evidence, tokenAddress, direction, optio
   };
 }
 
+// src/lib/token-batch-observer.ts
+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
+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/lib/helpers/funding-amount.ts
 function isFundingAmount(value, allowZero = false) {
   if (typeof value !== "string" || !/^\d{1,78}$/.test(value)) return false;
@@ -498,6 +520,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
@@ -526,6 +549,45 @@ 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: isAddress5, keccak256: keccak2564, parseTransaction: parseTransaction3, recoverTransactionAddress } = await import("viem");
+    const { validateTokenBatchAttempt: validateTokenBatchAttempt2 } = await import("./token-batch-family-VW6ZJLK5.js");
+    const phase = input.body.phase;
+    const original = phase === "approval" ? input.body.serializedPermitTransaction : input.body.serializedTransaction;
+    if (!original) throw failure();
+    const hash2 = keccak2564(original), relayer = await recoverTransactionAddress({ 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) || !isAddress5(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 = parseTransaction3(value.serializedTransaction), old = parseTransaction3(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
 import { bytesToHex as bytesToHex2 } from "viem";
@@ -1065,7 +1127,7 @@ async function submitZyfaiDeposit({ sdk, state, chain: chain2, amount, asset, sm
 
 // src/agents/zyfai/zyfai.agent.ts
 import { SMART_SESSIONS_VALIDATOR, ZyfaiSDK } from "@zyfai/sdk";
-import { erc20Abi as erc20Abi3, formatUnits as formatUnits2, isAddress as isAddress2, parseAbi as parseAbi3, parseUnits } from "viem";
+import { erc20Abi as erc20Abi3, formatUnits as formatUnits2, isAddress as isAddress2, parseAbi as parseAbi2, parseUnits } from "viem";
 import { base, arbitrum, mainnet } from "viem/chains";
 
 // src/lib/debug.ts
@@ -2023,7 +2085,7 @@ async function withPaidRpcDiagnostics(operation, chainId, rpcMethod, agentId) {
 }
 
 // src/agents/zyfai/zyfai.agent.ts
-var ERC7579_IS_MODULE_INSTALLED_ABI = parseAbi3([
+var ERC7579_IS_MODULE_INSTALLED_ABI = parseAbi2([
   "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)"
 ]);
 var WETH_ADDRESS_BY_CHAIN = {
@@ -2093,6 +2155,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
@@ -2110,6 +2173,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();
@@ -2285,6 +2351,8 @@ 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 () => {
@@ -2396,18 +2464,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 pending = 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) === pending) this.smartWalletReads.delete(key2);
+    });
+    this.smartWalletReads.set(key2, pending);
+    return pending;
+  }
   // --- IAgent: Connection lifecycle ---
   async disconnect() {
     const executionSdk = this.sdk;
@@ -2415,6 +2494,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);
@@ -2424,6 +2504,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();
@@ -3269,7 +3350,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
@@ -3384,8 +3465,13 @@ 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 pending = 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;
@@ -3405,20 +3491,37 @@ 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 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)
@@ -3576,10 +3679,10 @@ import {
   custom as custom4,
   decodeEventLog as decodeEventLog2,
   encodeEventTopics,
-  encodeFunctionData as encodeFunctionData2,
+  encodeFunctionData as encodeFunctionData3,
   erc20Abi as erc20Abi5,
-  erc4626Abi as erc4626Abi2,
-  getAddress as getAddress5,
+  erc4626Abi as erc4626Abi3,
+  getAddress as getAddress6,
   isAddress as isAddress4,
   parseUnits as parseUnits2
 } from "viem";
@@ -4656,13 +4759,13 @@ async function remainingVaultBalance(client, wallet, asset, vaults, blockNumber)
 import {
   getAddress as getAddress3,
   isAddressEqual,
-  parseAbi as parseAbi4
+  parseAbi as parseAbi3
 } from "viem";
 var YIELDSEEKER_FACTORY = "0x9c7410a0faCAC60850C46eE5b58B518daec95130";
 var YIELDSEEKER_V1_IMPLEMENTATION = "0x32403455357589523435dB18b414057D7cE05051";
 var YIELDSEEKER_V2_IMPLEMENTATION = "0x613Db9c924ADB7A7A90c11b02Cce20c913E3Fe50";
 var ERC1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
-var walletAbi = parseAbi4([
+var walletAbi = parseAbi3([
   "function owner() view returns (address)",
   "function ownerAgentIndex() view returns (uint256)",
   "function baseAsset() view returns (address)",
@@ -4670,7 +4773,7 @@ var walletAbi = parseAbi4([
   "function upgradeToLatest()",
   "event Upgraded(address indexed implementation)"
 ]);
-var factoryAbi = parseAbi4([
+var factoryAbi = parseAbi3([
   "function userWallets(address owner, uint256 index) view returns (address)",
   "function agentWalletImplementation() view returns (address)"
 ]);
@@ -5285,6 +5388,57 @@ async function submitYieldseekerSponsoredUpgrade(input) {
   return submitSmart({ ...input, owner, rpcUrl, expiresAt: intent.expiresAt });
 }
 
+// src/agents/yieldseeker/yieldseeker.vault-reads.ts
+import { decodeFunctionResult, encodeFunctionData as encodeFunctionData2, erc4626Abi as erc4626Abi2, getAddress as getAddress5, parseAbi as parseAbi4 } from "viem";
+var nativeAbi = parseAbi4([
+  "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 = getAddress5(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: erc4626Abi2, functionName: "asset" };
+  }
+}
+async function readNativeYieldseekerAssets(client, option, wallet, balance, blockNumber) {
+  if (nativeYieldseekerProtocol(option) !== "moonwell") {
+    return balance;
+  }
+  try {
+    const { data } = await client.call({
+      to: getAddress5(option.address),
+      blockNumber,
+      data: encodeFunctionData2({ abi: nativeAbi, functionName: "balanceOfUnderlying", args: [getAddress5(wallet)] })
+    });
+    if (!data) return void 0;
+    const assets = 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";
@@ -5294,7 +5448,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;
@@ -5381,6 +5536,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;
@@ -5397,6 +5553,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();
@@ -5404,6 +5561,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 = {}) {
@@ -5427,19 +5586,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 pending = readYieldseekerWalletStatus(
       this.getReceiptClient(),
-      getAddress5(context.wallet.walletAddress),
-      getAddress5(state.walletAddress),
+      getAddress6(context.wallet.walletAddress),
+      getAddress6(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) !== pending)
+        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) === pending) this.pendingWalletStatus.delete(key2);
+    });
+    this.pendingWalletStatus.set(key2, pending);
+    return { ...await pending };
   }
   rememberWalletStatus(key2, status) {
     if (status.verified && status.version === "v2") {
@@ -5465,6 +5636,7 @@ var YieldseekerAgent = class {
     const pendingKey2 = `owney.yieldseeker.upgrade:${before.owner.toLowerCase()}:${before.agentWallet.toLowerCase()}`;
     const confirmUpgrade = async (hash2, receipt2) => {
       this.withdrawalVersionCache.delete(versionKey);
+      this.pendingWalletStatus.delete(versionKey);
       const upgradeTopic = 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 = (() => {
@@ -5608,7 +5780,7 @@ var YieldseekerAgent = class {
         { version: before.version },
         this.id
       );
-    const data = encodeFunctionData2({ abi: YIELDSEEKER_UPGRADE_ABI, functionName: "upgradeToLatest" });
+    const data = encodeFunctionData3({ abi: YIELDSEEKER_UPGRADE_ABI, functionName: "upgradeToLatest" });
     let txHash;
     let receipt;
     if (gasMode === "sponsored") {
@@ -5651,7 +5823,7 @@ var YieldseekerAgent = class {
       let submittedHash;
       try {
         txHash = await this.submitTransaction(state, chainId, {
-          from: getAddress5(state.walletAddress),
+          from: getAddress6(state.walletAddress),
           to: before.agentWallet,
           data,
           value: "0",
@@ -5685,6 +5857,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()) {
@@ -5702,11 +5875,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);
@@ -5759,12 +5934,12 @@ var YieldseekerAgent = class {
     } else {
       try {
         txHash = await this.submitTransaction(state, chainId, {
-          from: getAddress5(state.walletAddress),
+          from: getAddress6(state.walletAddress),
           to: YIELDSEEKER_ASSET_METADATA[asset].address,
-          data: encodeFunctionData2({
+          data: encodeFunctionData3({
             abi: erc20Abi5,
             functionName: "transfer",
-            args: [getAddress5(context.wallet.walletAddress), BigInt(amount)]
+            args: [getAddress6(context.wallet.walletAddress), BigInt(amount)]
           }),
           value: "0",
           chainId
@@ -5827,7 +6002,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,
@@ -5910,7 +6088,7 @@ var YieldseekerAgent = class {
       );
       const positionsRead = this.readWithdrawalPositions(state, chainId, context);
       const metadata = YIELDSEEKER_ASSET_METADATA[asset];
-      const agentWallet = getAddress5(context.wallet.walletAddress);
+      const agentWallet = getAddress6(context.wallet.walletAddress);
       const readOwnerFunds = async (blockNumber) => {
         const feeTracker = await withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
           address: agentWallet,
@@ -5930,7 +6108,7 @@ var YieldseekerAgent = class {
             blockNumber
           }), chainId, "eth_call", this.id),
           withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
-            address: getAddress5(feeTracker),
+            address: getAddress6(feeTracker),
             abi: YIELDSEEKER_FEE_TRACKER_ABI,
             functionName: "getFeesOwed",
             args: [agentWallet],
@@ -5972,7 +6150,7 @@ 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 = getAddress5(position2.vaultOption.address);
+          const address = getAddress6(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;
@@ -5980,13 +6158,27 @@ var YieldseekerAgent = class {
             const [underlying, shares] = group.map((value) => value.result);
             if (typeof underlying !== "string" || !isAddress4(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: erc4626Abi2,
+                    abi: erc4626Abi3,
                     functionName,
                     args: [shares],
                     blockNumber
@@ -6227,7 +6419,7 @@ var YieldseekerAgent = class {
         delta: maxSettlementBasis.delta - payout,
         expectedNetDeposits: maxSettlementBasis.expectedNetDeposits - payout
       } : this.snapshotMovement(state, chainId, context, -payout);
-      const account = getAddress5(state.walletAddress);
+      const account = getAddress6(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 = {
@@ -6238,11 +6430,11 @@ var YieldseekerAgent = class {
       };
       if (base7.maxCompletion) notifyFunding(onProgress, base7);
       let submissionEvidence = base7;
-      const data = amount === void 0 ? encodeFunctionData2({
+      const data = amount === void 0 ? encodeFunctionData3({
         abi: YIELDSEEKER_AGENT_WALLET_ABI,
         functionName: "withdrawAllAssetToUser",
         args: [account, metadata.address]
-      }) : encodeFunctionData2({
+      }) : encodeFunctionData3({
         abi: YIELDSEEKER_AGENT_WALLET_ABI,
         functionName: "withdrawAssetToUser",
         args: [account, metadata.address, payout]
@@ -6259,7 +6451,7 @@ var YieldseekerAgent = class {
           refreshYieldseekerSignature: (rejected) => this.auth.refreshToken(state, chainId, rejected),
           userId: context.user.userId,
           agentId: context.agent.agentId,
-          agentWallet: getAddress5(context.wallet.walletAddress),
+          agentWallet: getAddress6(context.wallet.walletAddress),
           asset: metadata.address,
           callData: data,
           onPending: (pending) => {
@@ -6281,7 +6473,7 @@ var YieldseekerAgent = class {
           chainId,
           {
             from: account,
-            to: getAddress5(context.wallet.walletAddress),
+            to: getAddress6(context.wallet.walletAddress),
             data,
             value: "0",
             chainId
@@ -6426,28 +6618,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 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() && isAddress4(o.address));
-          if (!eligible.length) return unknown("INVENTORY_INCOMPLETE");
-          eligible.forEach((o) => vaults.add(o.address.toLowerCase()));
+          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) => !isAddress4(a)))
+        if (vaults.size > YIELDSEEKER_WITHDRAWAL_CANDIDATE_LIMIT || [...vaults.keys()].some((a) => !isAddress4(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: getAddress5(address),
-            abi: erc4626Abi2,
+            address: getAddress6(address),
+            abi: erc4626Abi3,
             functionName,
             args: [value],
             blockNumber
@@ -6467,15 +6666,15 @@ var YieldseekerAgent = class {
     }
   }
   async readVaultShares(options, wallet, blockNumber) {
-    const owner = getAddress5(wallet);
+    const owner = getAddress6(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 = getAddress5(option.address);
+        const address = getAddress6(option.address);
         return [
-          { address, abi: erc4626Abi2, functionName: "asset" },
+          yieldseekerUnderlyingCall(option),
           { address, abi: erc20Abi5, functionName: "balanceOf", args: [owner] }
         ];
       })
@@ -6554,7 +6753,7 @@ var YieldseekerAgent = class {
     const read2 = async () => {
       const client = this.getReceiptClient();
       const blockNumber = await client.getBlockNumber({ cacheTime: 0 });
-      const wallet = getAddress5(context.wallet.walletAddress);
+      const wallet = getAddress6(context.wallet.walletAddress);
       assertReadCurrent();
       if (typeof blockNumber !== "bigint") throw unavailable();
       const indexedPositions = this.validateWithdrawalPositions(positions ?? [], chainId, context.asset);
@@ -6582,7 +6781,7 @@ var YieldseekerAgent = class {
       if (typeof idle !== "bigint" || idle < 0n || !isAddress4(feeTracker) || /^0x0{40}$/i.test(feeTracker)) throw unavailable();
       assertReadCurrent();
       const fees = await client.readContract({
-        address: getAddress5(feeTracker),
+        address: getAddress6(feeTracker),
         abi: YIELDSEEKER_FEE_TRACKER_ABI,
         functionName: "getFeesOwed",
         args: [wallet],
@@ -6648,11 +6847,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: getAddress5(option.address),
-              abi: erc4626Abi2,
+              address: getAddress6(option.address),
+              abi: erc4626Abi3,
               functionName: "previewRedeem",
               args: [shares],
               blockNumber
@@ -6665,8 +6874,8 @@ var YieldseekerAgent = class {
           if (value === void 0 || value === 0n) {
             try {
               const converted = await client.readContract({
-                address: getAddress5(option.address),
-                abi: erc4626Abi2,
+                address: getAddress6(option.address),
+                abi: erc4626Abi3,
                 functionName: "convertToAssets",
                 args: [shares],
                 blockNumber
@@ -6757,7 +6966,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 = getAddress5(context.wallet.walletAddress);
+    const wallet = getAddress6(context.wallet.walletAddress);
     const asset = YIELDSEEKER_ASSET_METADATA[evidence.token];
     const client = this.getReceiptClient();
     const blockNumber = await client.getBlockNumber({ cacheTime: 0 });
@@ -6798,16 +7007,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);
@@ -6838,7 +7049,7 @@ var YieldseekerAgent = class {
       address: YIELDSEEKER_ASSET_METADATA[asset].address,
       abi: erc20Abi5,
       functionName: "balanceOf",
-      args: [getAddress5(context.wallet.walletAddress)]
+      args: [getAddress6(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");
@@ -7044,7 +7255,7 @@ var YieldseekerAgent = class {
       this.users.set(key2, persisted);
       return persisted;
     }
-    const walletAddress = getAddress5(state.walletAddress);
+    const walletAddress = getAddress6(state.walletAddress);
     const generation = this.readGeneration;
     let user = null;
     try {
@@ -7217,8 +7428,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);
@@ -7244,13 +7468,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);
     }
@@ -7295,7 +7521,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;
@@ -7303,6 +7529,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,
@@ -7310,7 +7538,7 @@ var YieldseekerAgent = class {
           contextKey,
           version,
           generation,
-          allocationChanged || this.snapshotMovements.has(contextKey) && (this.reconcileUntil.get(contextKey) ?? 0) > Date.now()
+          allocationChanged || settling
         );
       })
     };
@@ -7380,7 +7608,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,
@@ -7436,7 +7664,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);
@@ -7444,9 +7673,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) {
@@ -7462,10 +7693,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 {
@@ -7479,6 +7714,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;
     }
   }
@@ -7536,7 +7777,7 @@ var YieldseekerAgent = class {
       return hash3;
     }
     this.assertTransaction(transaction, state, chainId);
-    const account = getAddress5(state.walletAddress);
+    const account = getAddress6(state.walletAddress);
     const walletClient = createWalletClient4({
       account,
       chain: base4,
@@ -7557,7 +7798,7 @@ var YieldseekerAgent = class {
     const hash2 = await walletClient.sendTransaction({
       account,
       chain: base4,
-      to: getAddress5(transaction.to),
+      to: getAddress6(transaction.to),
       data: transaction.data,
       value: BigInt(transaction.value)
     });
@@ -7661,7 +7902,7 @@ var YieldseekerAgent = class {
     return receipt;
   }
   assertTransaction(transaction, state, chainId) {
-    if (!transaction || typeof transaction.from !== "string" || !isAddress4(transaction.from) || typeof transaction.to !== "string" || !isAddress4(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 || getAddress5(transaction.from) !== getAddress5(state.walletAddress)) {
+    if (!transaction || typeof transaction.from !== "string" || !isAddress4(transaction.from) || typeof transaction.to !== "string" || !isAddress4(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 || getAddress6(transaction.from) !== getAddress6(state.walletAddress)) {
       throw this.invalidResponse("transaction");
     }
   }
@@ -8878,7 +9119,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();
@@ -8904,8 +9145,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;
     }
   };
@@ -9572,7 +9813,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.
@@ -9582,7 +9823,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;
         }
@@ -9604,16 +9845,312 @@ import {
 } from "viem";
 import { base as base6, arbitrum as arbitrum3, mainnet as mainnet3 } from "viem/chains";
 
+// src/lib/token-batch-execution.ts
+import {
+  keccak256 as keccak2562,
+  parseTransaction
+} from "viem";
+async function executeTokenBatch(input, initial) {
+  let body = initial, family, ended = false;
+  const deadlineAt = Date.now() + 9e4, controller = new AbortController();
+  let timer;
+  const pending = () => 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 ? keccak2562(body.serializedTransaction) : body.serializedPermitTransaction ? keccak2562(body.serializedPermitTransaction) : void 0,
+      notSubmitted: false,
+      safeToFallback: false
+    }
+  );
+  const assertCurrent = () => {
+    if (ended || Date.now() >= deadlineAt) throw pending();
+    input.assertCurrent?.();
+  };
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      ended = true;
+      controller.abort();
+      reject(pending());
+    }, 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 (keccak2562(bytes) !== hash2) throw pending();
+    const tx = 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 pending();
+    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 ? keccak2562(initial.serializedTransaction) : initial.serializedPermitTransaction ? keccak2562(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 pending();
+          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 pending();
+      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 pending();
+          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
 import {
   isAddressEqual as isAddressEqual2,
-  encodeFunctionData as encodeFunctionData3,
-  keccak256 as keccak2562,
-  parseTransaction,
+  encodeFunctionData as encodeFunctionData4,
+  keccak256 as keccak2563,
+  parseTransaction as parseTransaction2,
   toBytes
 } from "viem";
-var memory = /* @__PURE__ */ new Map();
-var settledRecords = /* @__PURE__ */ new Map();
 var expiredRecords = /* @__PURE__ */ new Map();
 var inflight = /* @__PURE__ */ new Map();
 var planOf = (transfers) => JSON.stringify(
@@ -9622,18 +10159,7 @@ var planOf = (transfers) => JSON.stringify(
     amount: BigInt(t.amount).toString()
   }))
 );
-var pendingKey = (i) => `owney.token-batch.v1:${keccak2562(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 || !isAddressEqual2(body.from, i.owner) || !isAddressEqual2(body.token, i.token) || !body.transfers?.length) return;
-    return { txHash: keccak2562(body.serializedTransaction), transfers: body.transfers.map(({ to, amount }) => ({ to, amount })) };
-  } catch {
-    return;
-  }
-}
+var pendingKey = (i) => `owney.token-batch.v1:${keccak2563(toBytes(i.apiKey))}:${i.baseUrl ?? "default"}:${i.chainId}:${i.owner.toLowerCase()}:${i.token.toLowerCase()}`;
 async function releaseExpiredTokenBatch(i) {
   const key2 = pendingKey(i);
   let timer;
@@ -9642,7 +10168,7 @@ async function releaseExpiredTokenBatch(i) {
     let active2 = read(key2);
     if (active2 && i.expectedTxHash) {
       const current = JSON.parse(active2);
-      if (!current.serializedTransaction || keccak2562(current.serializedTransaction).toLowerCase() !== i.expectedTxHash.toLowerCase())
+      if (!current.serializedTransaction || keccak2563(current.serializedTransaction).toLowerCase() !== i.expectedTxHash.toLowerCase())
         active2 = void 0;
     }
     const archiveKey = i.expectedTxHash ? `${key2}:expired:${i.expectedTxHash.toLowerCase()}` : void 0;
@@ -9650,10 +10176,10 @@ async function releaseExpiredTokenBatch(i) {
     if (!saved) return;
     const body = JSON.parse(saved);
     if (!body.serializedTransaction || body.chainId !== i.chainId || !isAddressEqual2(body.from, i.owner) || !isAddressEqual2(body.token, i.token) || !body.transfers?.length) return;
-    const txHash = keccak2562(body.serializedTransaction);
+    const txHash = keccak2563(body.serializedTransaction);
     if (i.expectedTxHash && txHash.toLowerCase() !== i.expectedTxHash.toLowerCase()) return;
-    const transaction = parseTransaction(body.serializedTransaction);
-    if (transaction.chainId !== i.chainId || !transaction.to || !isAddressEqual2(transaction.to, BATCH_PERMIT2_ADDRESS) || (transaction.value ?? 0n) !== 0n || transaction.data !== encodeFunctionData3({
+    const transaction = parseTransaction2(body.serializedTransaction);
+    if (transaction.chainId !== i.chainId || !transaction.to || !isAddressEqual2(transaction.to, BATCH_PERMIT2_ADDRESS) || (transaction.value ?? 0n) !== 0n || transaction.data !== encodeFunctionData4({
       abi: PERMIT2_BATCH_ABI,
       functionName: "permitWitnessTransferFrom",
       args: batchArgs(body)
@@ -9682,8 +10208,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 };
   };
@@ -9701,37 +10226,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."
@@ -9748,136 +10253,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 || keccak2562(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 ? keccak2562(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 || keccak2562(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?.(keccak2562(body.serializedTransaction));
-      try {
-        i.onSubmitted?.(keccak2562(body.serializedTransaction));
-      } catch {
-      }
-      const hash2 = keccak2562(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 === keccak2562(body.serializedPermitTransaction)) {
-        await waitForConfirmation("approval", result.txHash);
-        result = await postSigned("deposit", hash2);
-        if (result?.status === "pending" && result.phase === "approval" && result.txHash === keccak2562(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 || !isAddressEqual2(previous.from, i.owner) || !isAddressEqual2(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 ? keccak2562(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 }
-      );
+      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 });
   }
@@ -9983,8 +10365,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
     });
   };
@@ -10071,7 +10454,7 @@ async function runAgentDepositBatch(chainId, legs, transfer) {
 }
 
 // src/lib/sponsored-calls-deposit.ts
-import { encodeFunctionData as encodeFunctionData4, erc20Abi as erc20Abi6, toHex as toHex3 } from "viem";
+import { encodeFunctionData as encodeFunctionData5, erc20Abi as erc20Abi6, toHex as toHex3 } from "viem";
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -10116,7 +10499,7 @@ function makeSponsoredCallsCallback(deps) {
     const calls = transfers.map((transfer) => ({
       to: token,
       value: "0x0",
-      data: encodeFunctionData4({
+      data: encodeFunctionData5({
         abi: erc20Abi6,
         functionName: "transfer",
         args: [transfer.to, BigInt(transfer.amount)]
@@ -10321,6 +10704,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();
@@ -10456,11 +10840,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,
@@ -10469,6 +10855,10 @@ 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
@@ -10484,7 +10874,7 @@ var OwneySDK = class {
         transport: custom5(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. */
@@ -10513,11 +10903,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,
@@ -10526,6 +10918,10 @@ 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
@@ -10541,7 +10937,7 @@ var OwneySDK = class {
         transport: custom5(provider)
       })
     });
-    if (!onApproved && !onSubmitted && !resumeTxHash && !onBeforeSubmission) this.cachedWethSponsoredCallback = callback;
+    if (!onApproved && !onSubmitted && !resumeTxHash && !onBeforeSubmission && !assertSubmissionCurrent) this.cachedWethSponsoredCallback = callback;
     return callback;
   }
   getAgent(agentId) {
@@ -10865,10 +11261,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) => {
@@ -10910,7 +11306,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) => {
@@ -10920,19 +11316,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 pending = 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 (!pending || 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();
         const candidates = agentId ? [this.getAgent(agentId)] : this.getEligibleAgents(chainId, asset);
         const wallets = await Promise.all(candidates.map(async (agent) => {
           this.validateAssetSupport(agent, chainId, asset);
@@ -11391,8 +11788,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({
@@ -11512,29 +11947,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. */
@@ -11686,7 +12157,7 @@ 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);
@@ -11698,7 +12169,10 @@ var OwneySDK = class {
     const wallet = createWalletClient5({
       account: walletAddress,
       chain: chain2,
-      transport: custom5(provider)
+      transport: custom5({ request: (args) => {
+        assertCurrent?.();
+        return provider.request(args);
+      } })
     });
     onStage?.("wrapping");
     const { wrapped } = await wrapNative(
@@ -11719,6 +12193,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,
@@ -12006,13 +12481,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();
@@ -12043,7 +12524,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.
@@ -12331,41 +12812,65 @@ 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) {
@@ -13682,7 +14187,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 });
@@ -13703,9 +14208,13 @@ var OwneySDK = class {
     const wallet = createWalletClient5({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: custom5(provider)
+      transport: custom5({ request: (args) => {
+        assertCurrent?.();
+        return provider.request(args);
+      } })
     });
     await ensureWalletOnChain(walletChainClient, wallet, chainId);
+    assertCurrent?.();
     const hash2 = await wallet.writeContract({
       address: token,
       abi: ERC20_ALLOWANCE_ABI,
@@ -13879,7 +14388,7 @@ var OwneySDK = class {
 };
 
 // src/agents/zyfai/zyfai.siwx.ts
-import { getAddress as getAddress6 } from "viem";
+import { getAddress as getAddress7 } from "viem";
 import { SiweMessage as SiweMessage2 } from "siwe";
 import { ZyfaiSDK as ZyfaiSDK2 } from "@zyfai/sdk";
 
@@ -14006,7 +14515,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new SiweMessage2({
-          address: getAddress6(accountAddress),
+          address: getAddress7(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,