@owney/sdk 0.7.25-beta.3 → 0.7.25-beta.6

package/dist/index.js

@@ -125,6 +125,34 @@ function rateLimitDelay(error, now = Date.now()) {
 }
 
 // src/lib/agent-reads.ts
+function rateLimitDiagnostics(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let details = {};
+  function visit(value, depth = 0) {
+    if (depth > 6 || !value || typeof value !== "object" || seen.has(value))
+      return;
+    seen.add(value);
+    const record = value;
+    for (const key2 of [
+      "rpcSource",
+      "chainId",
+      "rpcMethod",
+      "providerRequestId",
+      "statusCode"
+    ]) {
+      const candidate = record[key2];
+      if (candidate !== void 0 && details[key2] === void 0)
+        details = { ...details, [key2]: candidate };
+    }
+    for (const key2 of ["details", "cause", "response", "fields", "error"])
+      visit(record[key2], depth + 1);
+  }
+  visit(error);
+  return {
+    rpcSource: details.rpcSource ?? "agent-api",
+    ...details
+  };
+}
 var AgentReads = class {
   inFlight = /* @__PURE__ */ new Map();
   cooldowns = /* @__PURE__ */ new Map();
@@ -132,14 +160,15 @@ var AgentReads = class {
   clearInFlight() {
     this.inFlight.clear();
   }
-  limited(agentId, until) {
+  limited(agentId, until, diagnostics) {
     return new OwneyError(
       "AGENT_RATE_LIMITED",
       "Too many requests. Please wait before trying again.",
       {
         statusCode: 429,
         retryAt: until,
-        retryAfterSeconds: Math.max(0, Math.ceil((until - Date.now()) / 1e3))
+        retryAfterSeconds: Math.max(0, Math.ceil((until - Date.now()) / 1e3)),
+        ...diagnostics
       },
       agentId
     );
@@ -147,7 +176,9 @@ var AgentReads = class {
   run(agentId, key2, fetch2) {
     const cooldown = this.cooldowns.get(agentId);
     if (cooldown && cooldown.until > Date.now()) {
-      return Promise.reject(this.limited(agentId, cooldown.until));
+      return Promise.reject(
+        this.limited(agentId, cooldown.until, cooldown.diagnostics)
+      );
     }
     const requestKey = JSON.stringify([agentId, key2]);
     const existing = this.inFlight.get(requestKey);
@@ -168,8 +199,9 @@ var AgentReads = class {
           Math.min(3e4 * 2 ** (failures - 1), 3e5)
         );
         const until = Math.max(previous?.until ?? 0, Date.now() + delay);
-        this.cooldowns.set(agentId, { until, failures });
-        throw this.limited(agentId, until);
+        const diagnostics = rateLimitDiagnostics(error);
+        this.cooldowns.set(agentId, { until, failures, diagnostics });
+        throw this.limited(agentId, until, diagnostics);
       }
     ).finally(() => {
       if (this.inFlight.get(requestKey) === promise)
@@ -182,7 +214,7 @@ var AgentReads = class {
 
 // src/agents/zyfai/zyfai.agent.ts
 import { SMART_SESSIONS_VALIDATOR, ZyfaiSDK } from "@zyfai/sdk";
-import { createPublicClient, http, parseAbi } from "viem";
+import { parseAbi } from "viem";
 import { base, arbitrum, mainnet } from "viem/chains";
 
 // src/types/config.ts
@@ -1063,15 +1095,131 @@ function protocolsPolicyNeedsUpdate(current, desiredProtocols, desiredAutoSelect
   return !protocolListsEqual(current.protocols, desiredProtocols);
 }
 
+// src/lib/paid-rpc.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
+var PAID_RPC_RETRY_COUNT = 3;
+var PAID_RPC_RETRY_DELAY_MS = 1e3;
+var DEFAULT_RPC_URLS = {
+  1: "https://eth-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
+  8453: "https://base-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
+  42161: "https://arb-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V"
+};
+function resolveRpcUrl(rpcUrls, chainId) {
+  const url = rpcUrls?.[chainId]?.trim();
+  if (url) return url;
+  return DEFAULT_RPC_URLS[chainId];
+}
+function resolveRpcUrls(rpcUrls) {
+  return {
+    1: resolveRpcUrl(rpcUrls, 1),
+    8453: resolveRpcUrl(rpcUrls, 8453),
+    42161: resolveRpcUrl(rpcUrls, 42161)
+  };
+}
+function createPaidRpcClient(chain, rpcUrls) {
+  const url = resolveRpcUrl(
+    rpcUrls,
+    chain.id
+  );
+  return createPublicClient({
+    chain,
+    transport: http(url, {
+      retryCount: PAID_RPC_RETRY_COUNT,
+      retryDelay: PAID_RPC_RETRY_DELAY_MS
+    })
+  });
+}
+function headerValue(error, name) {
+  const seen = /* @__PURE__ */ new Set();
+  let value;
+  function visit(candidate, depth = 0) {
+    if (value || depth > 6 || !candidate || typeof candidate !== "object")
+      return;
+    if (seen.has(candidate)) return;
+    seen.add(candidate);
+    const record = candidate;
+    const headers = record.headers;
+    const found = typeof headers?.get === "function" ? headers.get(name) : headers?.[name] ?? headers?.[name.toLowerCase()];
+    if (typeof found === "string" && found) {
+      value = found;
+      return;
+    }
+    for (const key2 of ["cause", "details", "response", "error"])
+      visit(record[key2], depth + 1);
+  }
+  visit(error);
+  return value;
+}
+function statusCode(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let status;
+  function visit(candidate, depth = 0) {
+    if (status || depth > 6 || !candidate || typeof candidate !== "object")
+      return;
+    if (seen.has(candidate)) return;
+    seen.add(candidate);
+    const record = candidate;
+    for (const key2 of ["status", "statusCode"]) {
+      const parsed = Number(record[key2]);
+      if (Number.isInteger(parsed) && parsed >= 100 && parsed <= 599) {
+        status = parsed;
+        return;
+      }
+    }
+    for (const key2 of ["cause", "details", "response", "error"])
+      visit(record[key2], depth + 1);
+  }
+  visit(error);
+  return status;
+}
+function paidRpcError(error, chainId, rpcMethod, agentId) {
+  const delay = rateLimitDelay(error);
+  const providerRequestId = headerValue(error, "x-alchemy-request-id") ?? headerValue(error, "x-request-id");
+  if (delay === void 0) {
+    return new OwneyError(
+      "AGENT_API_ERROR",
+      "The blockchain RPC request failed.",
+      {
+        rpcSource: "paid-rpc",
+        chainId,
+        rpcMethod,
+        ...statusCode(error) ? { statusCode: statusCode(error) } : {},
+        ...providerRequestId ? { providerRequestId } : {}
+      },
+      agentId
+    );
+  }
+  const retryAt = Date.now() + delay;
+  return new OwneyError(
+    "AGENT_RATE_LIMITED",
+    "The blockchain RPC is rate limited. Please wait before trying again.",
+    {
+      rpcSource: "paid-rpc",
+      chainId,
+      rpcMethod,
+      statusCode: 429,
+      retryAt,
+      retryAfterSeconds: Math.max(0, Math.ceil(delay / 1e3)),
+      ...providerRequestId ? { providerRequestId } : {}
+    },
+    agentId
+  );
+}
+async function withPaidRpcDiagnostics(operation, chainId, rpcMethod, agentId) {
+  try {
+    return await operation();
+  } catch (error) {
+    throw paidRpcError(error, chainId, rpcMethod, agentId);
+  }
+}
+
 // src/agents/zyfai/zyfai.agent.ts
 var ERC7579_IS_MODULE_INSTALLED_ABI = parseAbi([
   "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)"
 ]);
-var DEFAULT_ZYFAI_RPC_URLS = {
-  8453: "https://base-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
-  42161: "https://arb-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
-  1: "https://eth-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V"
-};
 var WETH_ADDRESS_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
   42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -1137,7 +1285,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
   earningsSnapshot = null;
   earningsGeneration = 0;
   constructor(apiKey, rpcUrls, referralSource) {
-    this.rpcUrls = rpcUrls ?? DEFAULT_ZYFAI_RPC_URLS;
+    this.rpcUrls = resolveRpcUrls(rpcUrls);
     this.sdk = new ZyfaiSDK({
       apiKey,
       rpcUrls: this.rpcUrls,
@@ -1151,10 +1299,10 @@ var ZyfaiAgent = class _ZyfaiAgent {
   getPublicClient(chainId) {
     const cached = this.publicClients.get(chainId);
     if (cached) return cached;
-    const client = createPublicClient({
-      chain: VIEM_CHAIN[chainId],
-      transport: http(this.rpcUrls[chainId])
-    });
+    const client = createPaidRpcClient(
+      VIEM_CHAIN[chainId],
+      this.rpcUrls
+    );
     this.publicClients.set(chainId, client);
     return client;
   }
@@ -2328,12 +2476,13 @@ function randomPermit2Nonce() {
   globalThis.crypto.getRandomValues(bytes);
   return BigInt(bytesToHex2(bytes));
 }
-async function readPermit2Allowance(publicClient, token, owner) {
+async function readPermit2Allowance(publicClient, token, owner, blockNumber) {
   return publicClient.readContract({
     address: token,
     abi: ERC20_ALLOWANCE_ABI,
     functionName: "allowance",
-    args: [owner, PERMIT2_ADDRESS]
+    args: [owner, PERMIT2_ADDRESS],
+    ...blockNumber === void 0 ? {} : { blockNumber }
   });
 }
 async function readErc20Balance(publicClient, token, owner) {
@@ -3190,6 +3339,9 @@ var YIELDSEEKER_USERNAME_PREFIX = "owney_";
 var YIELDSEEKER_USERNAME_RANDOM_LENGTH = 14;
 var YIELDSEEKER_USERNAME_CREATE_ATTEMPTS = 3;
 var YIELDSEEKER_YIELD_OPTIONS_CACHE_MS = 6e4;
+var YIELDSEEKER_AGENT_LIST_CACHE_MS = 6e4;
+var YIELDSEEKER_PORTFOLIO_CACHE_MS = 3e4;
+var YIELDSEEKER_ACTIVITY_CACHE_MS = 6e4;
 function generateYieldseekerUsername() {
   const suffix = globalThis.crypto.randomUUID().replaceAll("-", "").slice(0, YIELDSEEKER_USERNAME_RANDOM_LENGTH).toLowerCase();
   return `${YIELDSEEKER_USERNAME_PREFIX}${suffix}`;
@@ -3233,6 +3385,7 @@ function query(params) {
 var YieldseekerAgent = class {
   id = "yieldseeker";
   balanceComposition = "tokens-plus-positions";
+  withdrawalRequiresWalletApproval = true;
   supportedChainIds = [8453];
   supportedAssets = [
     {
@@ -3246,11 +3399,17 @@ var YieldseekerAgent = class {
   ];
   api;
   auth;
+  rpcUrls;
+  receiptClient;
   transactionExecutor;
   unwindReceiptWaiter;
   agentContexts = /* @__PURE__ */ new Map();
   users = /* @__PURE__ */ new Map();
   pendingAgents = /* @__PURE__ */ new Map();
+  pendingWalletContexts = /* @__PURE__ */ new Map();
+  readCache = /* @__PURE__ */ new Map();
+  pendingReads = /* @__PURE__ */ new Map();
+  readGeneration = 0;
   yieldOptions = /* @__PURE__ */ new Map();
   pendingYieldOptions = /* @__PURE__ */ new Map();
   constructor(owneyApiKey, options = {}) {
@@ -3260,10 +3419,16 @@ var YieldseekerAgent = class {
       options.fetchFn
     );
     this.auth = new YieldseekerAuth(options.auth);
+    this.rpcUrls = options.rpcUrls;
     this.transactionExecutor = options.transactionExecutor;
     this.unwindReceiptWaiter = options.unwindReceiptWaiter;
   }
+  getReceiptClient() {
+    this.receiptClient ??= createPaidRpcClient(base3, this.rpcUrls);
+    return this.receiptClient;
+  }
   async disconnect() {
+    this.readGeneration += 1;
     this.auth.clear();
     for (const key2 of this.users.keys()) {
       const [walletAddress, chainId] = key2.split(":");
@@ -3272,6 +3437,9 @@ var YieldseekerAgent = class {
     this.users.clear();
     this.agentContexts.clear();
     this.pendingAgents.clear();
+    this.pendingWalletContexts.clear();
+    this.readCache.clear();
+    this.pendingReads.clear();
   }
   async activateAgent(state, chainId, asset) {
     this.assertChain(chainId);
@@ -3534,6 +3702,86 @@ var YieldseekerAgent = class {
   contextKey(state, chainId, asset) {
     return `${this.userKey(state, chainId)}:${asset}`;
   }
+  cachedRead(key2, ttlMs, read2) {
+    const cached = this.readCache.get(key2);
+    if (cached && cached.expiresAt > Date.now()) {
+      return Promise.resolve(cached.value);
+    }
+    const pending = this.pendingReads.get(key2);
+    if (pending) return pending;
+    const generation = this.readGeneration;
+    const request = Promise.resolve().then(read2).then((value) => {
+      if (this.readGeneration === generation) {
+        this.readCache.set(key2, {
+          expiresAt: Date.now() + ttlMs,
+          value
+        });
+      }
+      return value;
+    }).finally(() => {
+      if (this.pendingReads.get(key2) === request) {
+        this.pendingReads.delete(key2);
+      }
+    });
+    this.pendingReads.set(key2, request);
+    return request;
+  }
+  agentListKey(state, chainId) {
+    return `agents:${this.userKey(state, chainId)}`;
+  }
+  async listAgents(state, chainId, user) {
+    const response = await this.cachedRead(
+      this.agentListKey(state, chainId),
+      YIELDSEEKER_AGENT_LIST_CACHE_MS,
+      async () => {
+        const response2 = await this.walletRequest(
+          state,
+          chainId,
+          `/users/${user.userId}/agents`
+        );
+        if (!Array.isArray(response2?.agents)) {
+          throw this.invalidResponse("agent list");
+        }
+        return response2;
+      }
+    );
+    return response.agents;
+  }
+  async contextForAgent(state, chainId, user, agent, asset) {
+    const key2 = this.contextKey(state, chainId, asset);
+    const cached = this.agentContexts.get(key2);
+    if (cached?.agent.agentId === agent.agentId) return cached;
+    const pending = this.pendingWalletContexts.get(key2);
+    if (pending) return pending;
+    const generation = this.readGeneration;
+    const request = this.walletRequest(
+      state,
+      chainId,
+      `/users/${user.userId}/agents/${agent.agentId}/wallet`
+    ).then((walletResponse) => {
+      if (!walletResponse?.agentWallet || !isAddress2(walletResponse.agentWallet.walletAddress)) {
+        throw this.invalidResponse("agent wallet");
+      }
+      const context = {
+        user,
+        agent,
+        wallet: walletResponse.agentWallet,
+        asset
+      };
+      if (this.readGeneration === generation) {
+        this.agentContexts.set(key2, context);
+      }
+      return context;
+    });
+    this.pendingWalletContexts.set(key2, request);
+    try {
+      return await request;
+    } finally {
+      if (this.pendingWalletContexts.get(key2) === request) {
+        this.pendingWalletContexts.delete(key2);
+      }
+    }
+  }
   async resolveUser(state, chainId) {
     const key2 = this.userKey(state, chainId);
     const inMemory = this.users.get(key2);
@@ -3630,16 +3878,9 @@ var YieldseekerAgent = class {
   }
   async resolveAgent(state, chainId, asset, createIfMissing) {
     const user = await this.resolveUser(state, chainId);
-    const response = await this.walletRequest(
-      state,
-      chainId,
-      `/users/${user.userId}/agents`
-    );
-    if (!Array.isArray(response?.agents)) {
-      throw this.invalidResponse("agent list");
-    }
+    const agents = await this.listAgents(state, chainId, user);
     const metadata = YIELDSEEKER_ASSET_METADATA[asset];
-    let agent = response.agents.find(
+    let agent = agents.find(
       (candidate) => this.isOwneyAgent(candidate) && candidate.chainId === chainId && candidate.type === "vault" && candidate.assetAddress.toLowerCase() === metadata.address.toLowerCase()
     );
     if (!agent && createIfMissing) {
@@ -3660,83 +3901,91 @@ var YieldseekerAgent = class {
         }
       );
       agent = created?.agent;
+      if (agent) {
+        this.readCache.set(this.agentListKey(state, chainId), {
+          expiresAt: Date.now() + YIELDSEEKER_AGENT_LIST_CACHE_MS,
+          value: {
+            agents: [...agents, agent]
+          }
+        });
+      }
     }
     if (!agent) return null;
     this.assertAgent(agent);
-    const walletResponse = await this.walletRequest(
-      state,
-      chainId,
-      `/users/${user.userId}/agents/${agent.agentId}/wallet`
-    );
-    if (!walletResponse?.agentWallet || !isAddress2(walletResponse.agentWallet.walletAddress)) {
-      throw this.invalidResponse("agent wallet");
-    }
-    return { user, agent, wallet: walletResponse.agentWallet, asset };
+    return this.contextForAgent(state, chainId, user, agent, asset);
   }
   async loadPortfolio(state, chainId, options) {
     const user = await this.resolveUser(state, chainId);
-    const response = await this.walletRequest(
-      state,
-      chainId,
-      `/users/${user.userId}/agents`
-    );
-    if (!Array.isArray(response?.agents)) {
-      throw this.invalidResponse("agent list");
-    }
+    const agents = await this.listAgents(state, chainId, user);
     const contexts = [];
-    for (const agent of response.agents) {
+    for (const agent of agents) {
       const asset = this.assetForAgent(agent);
       if (!this.isOwneyAgent(agent) || !asset || agent.chainId !== chainId || agent.type !== "vault" || options.asset && options.asset !== asset) {
         continue;
       }
       this.assertAgent(agent);
-      const walletResponse = await this.walletRequest(
-        state,
-        chainId,
-        `/users/${user.userId}/agents/${agent.agentId}/wallet`
-      );
-      if (!walletResponse?.agentWallet || !isAddress2(walletResponse.agentWallet.walletAddress)) {
-        throw this.invalidResponse("agent wallet");
-      }
-      const context = {
-        user,
-        agent,
-        wallet: walletResponse.agentWallet,
-        asset
-      };
-      this.agentContexts.set(this.contextKey(state, chainId, asset), context);
-      contexts.push(context);
+      contexts.push(this.contextForAgent(state, chainId, user, agent, asset));
     }
+    const resolvedContexts = await Promise.all(contexts);
     return Promise.all(
-      contexts.map(
+      resolvedContexts.map(
         (context) => this.loadPortfolioContext(state, chainId, context, options)
       )
     );
   }
   async loadPortfolioContext(state, chainId, context, options = {}) {
+    const contextKey = this.contextKey(state, chainId, context.asset);
     const [snapshot, positions, historic, actions] = await Promise.all([
-      this.walletRequest(
-        state,
-        chainId,
-        `${this.agentPath(context, "snapshot")}${query({
-          shouldOnlyUseRecentValue: true,
-          shouldAllowStaleOnError: true
-        })}`
+      this.cachedRead(
+        `snapshot:${contextKey}`,
+        YIELDSEEKER_PORTFOLIO_CACHE_MS,
+        async () => {
+          const response = await this.walletRequest(
+            state,
+            chainId,
+            `${this.agentPath(context, "snapshot")}${query({
+              shouldOnlyUseRecentValue: true,
+              shouldAllowStaleOnError: true
+            })}`
+          );
+          if (!response?.agentSnapshot) {
+            throw this.invalidResponse("agent snapshot");
+          }
+          return response;
+        }
       ),
-      this.walletRequest(
-        state,
-        chainId,
-        this.agentPath(context, "yield-positions")
+      this.cachedRead(
+        `positions:${contextKey}`,
+        YIELDSEEKER_PORTFOLIO_CACHE_MS,
+        async () => {
+          const response = await this.walletRequest(
+            state,
+            chainId,
+            this.agentPath(context, "yield-positions")
+          );
+          if (!Array.isArray(response?.yieldPositions)) {
+            throw this.invalidResponse("yield positions");
+          }
+          return response;
+        }
       ),
-      options.historic ? this.walletRequest(
-        state,
-        chainId,
-        this.agentPath(context, "wallet/historic-position")
+      options.historic ? this.cachedRead(
+        `historic:${contextKey}`,
+        YIELDSEEKER_ACTIVITY_CACHE_MS,
+        () => this.walletRequest(
+          state,
+          chainId,
+          this.agentPath(context, "wallet/historic-position")
+        )
       ) : Promise.resolve(void 0),
-      options.actions ? this.walletRequest(
-        state,
-        chainId,
-        this.agentPath(context, "actions")
+      options.actions ? this.cachedRead(
+        `actions:${contextKey}`,
+        YIELDSEEKER_ACTIVITY_CACHE_MS,
+        () => this.walletRequest(
+          state,
+          chainId,
+          this.agentPath(context, "actions")
+        )
       ) : Promise.resolve(void 0)
     ]);
     if (!snapshot?.agentSnapshot) {
@@ -3770,6 +4019,13 @@ var YieldseekerAgent = class {
     context.wallet = deployed.agentWallet;
   }
   async refreshSnapshotAfterMovement(state, chainId, context, movement) {
+    const contextKey = this.contextKey(state, chainId, context.asset);
+    const invalidatePortfolio = () => {
+      for (const kind of ["snapshot", "positions", "historic", "actions"]) {
+        this.readCache.delete(`${kind}:${contextKey}`);
+      }
+    };
+    invalidatePortfolio();
     try {
       const response = await this.walletRequest(
         state,
@@ -3786,6 +4042,8 @@ var YieldseekerAgent = class {
         `[owney-sdk] Yieldseeker ${movement} snapshot refresh failed:`,
         error
       );
+    } finally {
+      invalidatePortfolio();
     }
   }
   agentPath(context, suffix) {
@@ -3836,6 +4094,7 @@ var YieldseekerAgent = class {
       code,
       `Yieldseeker request failed: ${error.providerCode}.`,
       {
+        rpcSource: "agent-api",
         statusCode: error.status,
         providerCode: error.providerCode,
         ...error.responseFields ? { fields: error.responseFields } : {}
@@ -3854,12 +4113,12 @@ var YieldseekerAgent = class {
       chain: base3,
       transport: custom2(state.provider)
     });
-    const publicClient = createPublicClient3({
+    const walletChainClient = createPublicClient3({
       chain: base3,
       transport: custom2(state.provider)
     });
     await ensureWalletOnChain(
-      publicClient,
+      walletChainClient,
       walletClient,
       8453
     );
@@ -3870,10 +4129,15 @@ var YieldseekerAgent = class {
       data: transaction.data,
       value: BigInt(transaction.value)
     });
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash,
-      confirmations: 1
-    });
+    const receipt = await withPaidRpcDiagnostics(
+      () => this.getReceiptClient().waitForTransactionReceipt({
+        hash,
+        confirmations: 1
+      }),
+      8453,
+      "eth_getTransactionReceipt",
+      this.id
+    );
     if (receipt.status !== "success") {
       throw new OwneyError(
         "AGENT_TRANSACTION_REVERTED",
@@ -3889,14 +4153,15 @@ var YieldseekerAgent = class {
       await this.unwindReceiptWaiter(state, chainId, transactionHash);
       return;
     }
-    const publicClient = createPublicClient3({
-      chain: base3,
-      transport: custom2(state.provider)
-    });
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash: transactionHash,
-      confirmations: 1
-    });
+    const receipt = await withPaidRpcDiagnostics(
+      () => this.getReceiptClient().waitForTransactionReceipt({
+        hash: transactionHash,
+        confirmations: 1
+      }),
+      8453,
+      "eth_getTransactionReceipt",
+      this.id
+    );
     if (receipt.status !== "success") {
       throw new OwneyError(
         "AGENT_TRANSACTION_REVERTED",
@@ -4268,6 +4533,41 @@ import {
 // src/lib/permit2-batch.ts
 import { parseAbi as parseAbi2, hashStruct } from "viem";
 var BATCH_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+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 = parseAbi2([
+  "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[]" },
@@ -4419,28 +4719,67 @@ async function execute(i, key2, plan) {
       "DEPOSIT_INSUFFICIENT_BALANCE",
       "Insufficient token balance for this deposit."
     );
-  if (allowance < total)
+  if (allowance < total && (i.chainId !== 8453 || !isAddressEqual(i.token, BASE_USDC_ADDRESS)))
     throw new OwneyError(
       "PERMIT2_APPROVAL_REQUIRED",
       "token deposits need a one-time Permit2 approval."
     );
-  const relayer = await getSponsorRelayerAddress({
+  const now = (await i.pub.getBlock()).timestamp;
+  let erc2612Permit;
+  if (allowance < total) {
+    const [tokenName, tokenVersion, permitNonce] = await Promise.all([
+      i.pub.readContract({
+        address: i.token,
+        abi: ERC2612_READ_ABI,
+        functionName: "name"
+      }),
+      i.pub.readContract({
+        address: i.token,
+        abi: ERC2612_READ_ABI,
+        functionName: "version"
+      }),
+      i.pub.readContract({
+        address: i.token,
+        abi: ERC2612_READ_ABI,
+        functionName: "nonces",
+        args: [i.owner]
+      })
+    ]);
+    const unsignedPermit = {
+      value: MAX_UINT256.toString(),
+      nonce: permitNonce.toString(),
+      deadline: (now + 900n).toString(),
+      tokenName,
+      tokenVersion
+    };
+    const signature2 = await i.wallet.signTypedData({
+      account: i.owner,
+      ...erc2612TypedData({
+        chainId: 8453,
+        token: i.token,
+        owner: i.owner,
+        permit: unsignedPermit
+      })
+    });
+    erc2612Permit = { ...unsignedPermit, signature: signature2 };
+  }
+  const spender = erc2612Permit ? MULTICALL3_ADDRESS : await getSponsorRelayerAddress({
     apiKey: i.apiKey,
     baseUrl: i.baseUrl,
     chainId: i.chainId
   });
-  const now = (await i.pub.getBlock()).timestamp;
   const unsigned = {
     chainId: i.chainId,
     token: i.token,
     from: i.owner,
     transfers: i.transfers,
     nonce: randomPermit2Nonce().toString(),
-    deadline: (now + 900n).toString()
+    deadline: (now + 900n).toString(),
+    ...erc2612Permit ? { erc2612Permit } : {}
   };
   const signature = await i.wallet.signTypedData({
     account: i.owner,
-    ...batchTypedData(unsigned, relayer)
+    ...batchTypedData(unsigned, spender)
   });
   i.onApproved?.();
   return send({ ...unsigned, signature });
@@ -4460,8 +4799,8 @@ function makeSponsoredTokenCallback(deps) {
         "CHAIN_UNSUPPORTED",
         `No sponsored token configured for chain ${chainId}`
       );
-    const pub = deps.getPublicClient(chainId), wallet = deps.getWalletClient(chainId);
-    await ensureWalletOnChain(pub, wallet, chainId);
+    const pub = deps.getPublicClient(chainId), walletChain = deps.getWalletChainClient?.(chainId) ?? pub, wallet = deps.getWalletClient(chainId);
+    await ensureWalletOnChain(walletChain, wallet, chainId);
     return sponsorTokenBatch({
       apiKey: deps.apiKey,
       baseUrl: deps.baseUrl,
@@ -4701,6 +5040,8 @@ function makeSponsoredCallsCallback(deps) {
 }
 
 // src/client.ts
+var PERMIT2_ALLOWANCE_VERIFY_ATTEMPTS = 6;
+var PERMIT2_ALLOWANCE_VERIFY_DELAY_MS = 250;
 function encodeMultiAgentCursor(map) {
   return Buffer.from(JSON.stringify(map), "utf8").toString("base64");
 }
@@ -4761,6 +5102,7 @@ var OwneySDK = class {
   // leave every user's agent profile alone.
   orgAgentConfig;
   orgAgentConfigPromise = null;
+  rpcUrls;
   zyfaiRpcUrls;
   yieldseekerApiBaseUrl;
   yieldseekerSiweOrigin;
@@ -4785,6 +5127,7 @@ var OwneySDK = class {
   constructor(config) {
     this.apiKey = config.apiKey;
     if (config.debug) setOwneyDebug(true);
+    this.rpcUrls = config.rpcUrls;
     this.zyfaiRpcUrls = config.zyfaiRpcUrls;
     this.yieldseekerApiBaseUrl = config.yieldseekerApiBaseUrl;
     this.yieldseekerSiweOrigin = config.yieldseekerSiweOrigin;
@@ -4875,6 +5218,9 @@ var OwneySDK = class {
     }
     return this.state.provider;
   }
+  getPaidRpcClient(chainId) {
+    return createPaidRpcClient(VIEM_CHAIN2[chainId], this.rpcUrls);
+  }
   /** Builds the default USDC batch callback for the connected wallet. */
   getDefaultSponsoredCallback(onApproved) {
     if (!onApproved && this.cachedSponsoredCallback)
@@ -4890,7 +5236,8 @@ var OwneySDK = class {
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
       // runtime, but the two share a name TS treats as unrelated.
-      getPublicClient: (cid) => createPublicClient4({
+      getPublicClient: (cid) => this.getPaidRpcClient(cid),
+      getWalletChainClient: (cid) => createPublicClient4({
         chain: VIEM_CHAIN2[cid],
         transport: custom3(provider)
       }),
@@ -4940,7 +5287,8 @@ var OwneySDK = class {
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
       // runtime, but the two share a name TS treats as unrelated.
-      getPublicClient: (cid) => createPublicClient4({
+      getPublicClient: (cid) => this.getPaidRpcClient(cid),
+      getWalletChainClient: (cid) => createPublicClient4({
         chain: VIEM_CHAIN2[cid],
         transport: custom3(provider)
       }),
@@ -5053,12 +5401,17 @@ var OwneySDK = class {
   createAgent(agentId, key2) {
     if (agentId === "zyfai") {
       if (!key2) return null;
-      return new ZyfaiAgent(key2, this.zyfaiRpcUrls, this.referralSource);
+      return new ZyfaiAgent(
+        key2,
+        this.rpcUrls ?? this.zyfaiRpcUrls,
+        this.referralSource
+      );
     }
     if (agentId === "yieldseeker") {
       return new YieldseekerAgent(this.apiKey, {
         auth: { origin: this.yieldseekerSiweOrigin },
-        baseUrl: this.yieldseekerApiBaseUrl ?? getYieldseekerProxyBaseUrl(this.routingApiBaseUrl)
+        baseUrl: this.yieldseekerApiBaseUrl ?? getYieldseekerProxyBaseUrl(this.routingApiBaseUrl),
+        rpcUrls: this.rpcUrls
       });
     }
     return null;
@@ -5349,7 +5702,8 @@ var OwneySDK = class {
             );
             await this.approvePermit2(
               asset,
-              requiredAmount
+              requiredAmount,
+              cid
             );
             return batchTransfer(cid, transfers);
           }
@@ -5393,10 +5747,12 @@ var OwneySDK = class {
    * Invokes `agent.deposit` with the resolved sponsored callback, composing
    * two independent auto-recovery mechanisms:
    *
-   * 1. Missing Permit2 allowance: when the app did not supply its own
-   *    callback and the attempt fails with `PERMIT2_APPROVAL_REQUIRED` on a
-   *    token deposit, this is the wallet's first Permit2 deposit for that token. We send
-   *    the one-time (user-paid) Permit2 approval via `approvePermit2()` and
+   * 1. Missing Permit2 allowance outside the atomic Base-USDC path: when the
+   *    app did not supply its own callback and the attempt fails with
+   *    `PERMIT2_APPROVAL_REQUIRED`, this is the wallet's first Permit2 deposit
+   *    for that token. Base USDC bundles a gasless ERC-2612 approval inside
+   *    its sponsored deposit and never reaches this branch. Other tokens send
+   *    the one-time user-paid Permit2 approval via `approvePermit2()` and
    *    retry the SAME sponsored attempt once. Bounded to one approval attempt
    *    per call so a wallet/agent that keeps reporting the allowance as
    *    missing can't loop forever. If `approvePermit2()` itself throws (e.g.
@@ -5439,7 +5795,8 @@ var OwneySDK = class {
           );
           await this.approvePermit2(
             asset,
-            BigInt(amount)
+            BigInt(amount),
+            chainId
           );
           continue;
         }
@@ -5586,6 +5943,32 @@ var OwneySDK = class {
     }
     return eligible;
   }
+  /**
+   * Run owner-approved withdrawals before relayer-only withdrawals. Wallet
+   * approval is the only point at which the user can cancel the aggregate
+   * operation, so no relayer leg should commit before it has completed.
+   */
+  orderAgentsForWithdrawal(agents) {
+    return agents.map((agent, index) => ({ agent, index })).sort((left, right) => {
+      const approvalOrder = Number(Boolean(right.agent.withdrawalRequiresWalletApproval)) - Number(Boolean(left.agent.withdrawalRequiresWalletApproval));
+      return approvalOrder || left.index - right.index;
+    }).map(({ agent }) => agent);
+  }
+  isUserRejectedWithdrawal(error) {
+    let current = error;
+    const seen = /* @__PURE__ */ new Set();
+    while (current && typeof current === "object" && !seen.has(current)) {
+      seen.add(current);
+      const candidate = current;
+      if (candidate.code === 4001 || candidate.code === "4001") return true;
+      const message = [candidate.message, candidate.shortMessage].filter((value) => typeof value === "string").join(" ");
+      if (/user (?:rejected|denied)|rejected by user/i.test(message)) {
+        return true;
+      }
+      current = candidate.cause;
+    }
+    return false;
+  }
   // --- Fund operations ---
   /**
    * Withdraw funds from a specific agent, or all agents that support the active chain+asset if agentId is omitted.
@@ -5621,13 +6004,15 @@ var OwneySDK = class {
       );
     }
     const eligibleAgents = this.getEligibleAgents(chainId, asset);
+    const withdrawalAgents = this.orderAgentsForWithdrawal(eligibleAgents);
     if (!amount) {
       const results2 = {};
       const agentErrors2 = {};
-      for (const agent of eligibleAgents) {
+      for (const agent of withdrawalAgents) {
         try {
           results2[agent.id] = await agent.withdraw(state, chainId, token);
         } catch (err) {
+          if (this.isUserRejectedWithdrawal(err)) throw err;
           console.error(`withdraw failed for agent "${agent.id}":`, err);
           agentErrors2[agent.id] = err instanceof Error ? err.message : String(err);
           const code = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
@@ -5708,12 +6093,13 @@ var OwneySDK = class {
       planned: 0n
     }));
     const plans = [...disabledPlans, ...enabledPlans];
+    const orderedPlans = this.orderAgentsForWithdrawal(plans.map((p) => p.agent)).map((agent) => plans.find((plan) => plan.agent === agent));
     const results = {};
     const agentErrors = {
       ...aggregated.agentErrors ?? {}
     };
-    for (let i = 0; i < plans.length; i++) {
-      const p = plans[i];
+    for (let i = 0; i < orderedPlans.length; i++) {
+      const p = orderedPlans[i];
       if (p.planned === 0n) continue;
       try {
         results[p.agent.id] = await p.agent.withdraw(
@@ -5723,6 +6109,7 @@ var OwneySDK = class {
           p.planned.toString()
         );
       } catch (err) {
+        if (this.isUserRejectedWithdrawal(err)) throw err;
         console.error(`withdraw failed for agent "${p.agent.id}":`, err);
         agentErrors[p.agent.id] = err instanceof Error ? err.message : String(err);
         const code = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
@@ -5734,7 +6121,7 @@ var OwneySDK = class {
         );
         const failedAmount = p.planned;
         p.planned = 0n;
-        redistributeShare(plans, i, failedAmount);
+        redistributeShare(orderedPlans, i, failedAmount);
       }
     }
     if (Object.keys(results).length === 0) {
@@ -6162,14 +6549,16 @@ var OwneySDK = class {
    * User-paid approval of Permit2 on the selected token for the active chain.
    * Grants the maximum ERC20 allowance so later deposits do not require another
    * approval. Resolves after one confirmation so the subsequent deposit attempt
-   * sees the new allowance.
+   * sees the new allowance. Deposit retries pass their captured chain id so a
+   * concurrent activation cannot redirect the approval to another network.
    *
    * @param requiredAmount Raw base-unit amount the pending deposit must cover.
+   * @param expectedChainId Chain captured by the deposit that requested approval.
    * @returns the approval transaction hash.
    */
-  async approvePermit2(asset = "WETH", requiredAmount = 0n) {
+  async approvePermit2(asset = "WETH", requiredAmount = 0n, expectedChainId) {
     const state = this.requireState();
-    const chainId = this.requireChainId();
+    const chainId = expectedChainId ?? this.requireChainId();
     this.getEligibleAgents(chainId, asset, { excludeDisabled: true });
     const token = sponsoredTokensFor(asset)[chainId];
     if (!token) {
@@ -6179,16 +6568,18 @@ var OwneySDK = class {
       );
     }
     const provider = this.requireConnectedProvider();
-    const publicClient = createPublicClient4({
+    const walletChainClient = createPublicClient4({
       chain: VIEM_CHAIN2[chainId],
       transport: custom3(provider)
     });
+    const publicClient = this.getPaidRpcClient(chainId);
     const approvalAmount = permit2ApprovalAmount(requiredAmount);
     const wallet = createWalletClient3({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
       transport: custom3(provider)
     });
+    await ensureWalletOnChain(walletChainClient, wallet, chainId);
     const hash = await wallet.writeContract({
       address: token,
       abi: ERC20_ALLOWANCE_ABI,
@@ -6197,14 +6588,53 @@ var OwneySDK = class {
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId]
     });
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash,
-      confirmations: 1
-    });
+    const receipt = await withPaidRpcDiagnostics(
+      () => publicClient.waitForTransactionReceipt({
+        hash,
+        confirmations: 1
+      }),
+      chainId,
+      "eth_getTransactionReceipt"
+    );
     if (receipt.status !== "success") {
       throw new Error(`Permit2 approval reverted (tx ${hash})`);
     }
-    return hash;
+    let observedAllowance = 0n;
+    let verificationError;
+    for (let attempt = 0; attempt < PERMIT2_ALLOWANCE_VERIFY_ATTEMPTS; attempt += 1) {
+      try {
+        observedAllowance = await readPermit2Allowance(
+          publicClient,
+          token,
+          state.walletAddress,
+          attempt === 0 ? receipt.blockNumber : void 0
+        );
+        verificationError = void 0;
+        if (observedAllowance >= requiredAmount) return hash;
+      } catch (error) {
+        verificationError = error;
+      }
+      if (attempt + 1 < PERMIT2_ALLOWANCE_VERIFY_ATTEMPTS) {
+        await new Promise(
+          (resolve) => setTimeout(resolve, PERMIT2_ALLOWANCE_VERIFY_DELAY_MS)
+        );
+      }
+    }
+    throw new OwneyError(
+      "PERMIT2_APPROVAL_REQUIRED",
+      "Permit2 approval was confirmed, but the required token allowance was not observable.",
+      {
+        approvalConfirmed: true,
+        approvalTxHash: hash,
+        owner: state.walletAddress,
+        token,
+        spender: PERMIT2_ADDRESS,
+        chainId,
+        requiredAmount: requiredAmount.toString(),
+        observedAllowance: observedAllowance.toString(),
+        ...verificationError instanceof Error ? { verificationError: verificationError.message } : {}
+      }
+    );
   }
   // --- Discovery (no wallet required) ---
   /**