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

package/dist/index.d.ts

@@ -392,7 +392,7 @@ declare class OwneySDK {
     private routingApiBaseUrl?;
     private referralSource?;
     private cachedSponsoredCallback;
-    private cachedPermit2Callbacks;
+    private cachedWethSponsoredCallback;
     private initializingAgentsPromise;
     constructor(config: OwneySDKConfig);
     /**
@@ -428,21 +428,12 @@ declare class OwneySDK {
      */
     private getDefaultSponsoredCallback;
     /**
-     * Lazily builds (and caches) the Permit2 sponsored callback for one asset.
-     * Used for WETH always, and for USDC when the connected owner is a smart
-     * account — EIP-3009 verifies with ecrecover inside USDC and cannot accept a
-     * contract signature, while Permit2 supports ERC-1271.
+     * Lazily builds (and caches) the default Permit2 sponsored WETH deposit
+     * callback used when the caller omits `depositCallback` for a WETH
+     * deposit. Mirrors `getDefaultSponsoredCallback()` but signs a Permit2
+     * `PermitTransferFrom` instead of an EIP-3009 authorization.
      */
-    private getDefaultPermit2Callback;
-    /**
-     * True when the connected owner has bytecode — a deployed smart wallet, or an
-     * EOA carrying an EIP-7702 delegation (the Base app's "Upgrade your wallet").
-     * Such wallets sign via ERC-1271, which EIP-3009 cannot verify.
-     *
-     * Fails OPEN: an unreadable code check returns false so a working EOA deposit
-     * is never blocked by a flaky provider.
-     */
-    private ownerHasCode;
+    private getDefaultWethSponsoredCallback;
     private getAgent;
     private getActiveAgents;
     /**
@@ -492,16 +483,13 @@ declare class OwneySDK {
      * 1. Missing Permit2 allowance: when the app did not supply its own
      *    callback and the attempt fails with `PERMIT2_APPROVAL_REQUIRED` on a
      *    WETH deposit, this is the wallet's first gasless WETH deposit. We send
-     *    the one-time (user-paid) Permit2 approval via `approvePermit2()`, wait
-     *    for the new allowance to actually be readable via
-     *    `waitForPermit2Allowance()` (the wallet's own RPC can lag a freshly
-     *    mined tx), then 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. the user rejects the wallet prompt), that error
-     *    propagates as-is — the user said no to a transaction, so we must not
-     *    turn around and ask them to pay for a different one via the fallback
-     *    below.
+     *    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.
+     *    the user rejects the wallet prompt), that error propagates as-is —
+     *    the user said no to a transaction, so we must not turn around and ask
+     *    them to pay for a different one via the fallback below.
      * 2. `shouldFallbackToUserPaid`: the SDK's own WETH sponsor path failed at
      *    the infrastructure layer in a provably safe-to-retry way, so we warn
      *    and retry once with `undefined`, falling through to a user-paid
@@ -513,18 +501,6 @@ declare class OwneySDK {
      * propagates unchanged. Scoped per agent invocation so one agent's failure
      * doesn't force a retry of sibling agents in a multi-agent split.
      */
-    /**
-     * Polls the owner's Permit2 allowance for `asset` until it covers `amount`
-     * or the attempt budget runs out. Called right after `approvePermit2()`
-     * resolves: the approval tx is mined, but the wallet's own RPC can still
-     * serve a stale (zero) allowance on the very next read (replica lag), which
-     * would otherwise make the immediate retry fail with the same
-     * PERMIT2_APPROVAL_REQUIRED error the user just approved past. Never
-     * throws — if the allowance still hasn't caught up after the budget, the
-     * caller's retry will surface the honest PERMIT2_APPROVAL_REQUIRED error
-     * rather than this helper inventing a different one.
-     */
-    private waitForPermit2Allowance;
     private depositWithFallback;
     private getMinDepositAmount;
     private splitDepositAmount;
@@ -602,16 +578,14 @@ declare class OwneySDK {
      */
     ensureAutoSelectProtocols(asset: "USDC" | "WETH", agentId?: AgentId): Promise<boolean>;
     /**
-     * One-time, user-paid approval of Permit2 on the given sponsored token for
-     * the active chain. Required once per wallet per chain per token before a
-     * gasless deposit of that asset over Permit2; afterwards deposit() is
-     * signature-only for it. This call itself is a real transaction the user
-     * pays gas for. Resolves only after the approval transaction is mined (1
-     * confirmation), so a subsequent deposit() will see the new allowance;
-     * throws if the transaction reverted.
+     * One-time, user-paid approval of Permit2 on the sponsored WETH token for
+     * the active chain. Required once per wallet per chain before gasless WETH
+     * deposits; afterwards deposit() is signature-only. Resolves only after the
+     * approval transaction is mined (1 confirmation), so a subsequent deposit()
+     * will see the new allowance; throws if the transaction reverted.
      * @returns the approval transaction hash.
      */
-    approvePermit2(asset?: "WETH" | "USDC"): Promise<`0x${string}`>;
+    approvePermit2(asset?: "WETH"): Promise<`0x${string}`>;
     /**
      * Get the agent's average APY performance over a time period. Does not require a wallet connection.
      * @param options - Contains agentId (optional) and days ("7D", "14D", or "30D")

package/dist/index.js

@@ -846,6 +846,12 @@ var ZyfaiAgent = class {
   connectedAddress = null;
   connectedChainId = null;
   smartWalletCache = /* @__PURE__ */ new Map();
+  /**
+   * `${eoa}:${chainId}` keys we have already tried createSessionKey for. Guards
+   * against re-running it on every activation/deposit when Zyfai's
+   * `hasActiveSessionKey` does not flip to true — see ensureSessionKey.
+   */
+  sessionKeyAttempts = /* @__PURE__ */ new Set();
   connectAuthPromise = null;
   rpcUrls;
   publicClients = /* @__PURE__ */ new Map();
@@ -1303,10 +1309,74 @@ var ZyfaiAgent = class {
    * recoverable (ensureWalletDeployed tries the other deploy call), but
    * failing the deposit outright is not.
    */
+  /**
+   * Zyfai's own answer to "what kind of wallet is this, and can the agent act on
+   * it", read from the positions payload (`GET /data/position`, which
+   * `getPositions` wraps).
+   *
+   * `predeployed` and `hasActiveSessionKey` are both returned at runtime but
+   * declared on neither `Portfolio` nor their docs, hence the cast. Verified
+   * live: an old wallet reports `{predeployed: false, hasActiveSessionKey:
+   * false}` while a pool wallet reports `{true, true}`.
+   *
+   * Preferred over the SDK's private `isPredeployed`, which is cached from the
+   * login response and can go stale mid-session. Returns an empty object on any
+   * failure so every caller degrades to its own fallback.
+   */
+  async readWalletState(ownerAddress) {
+    try {
+      const { portfolio } = await this.sdk.getPositions(ownerAddress);
+      const raw = portfolio;
+      debugLog("zyfai:onboard", "wallet state from getPositions", {
+        predeployed: raw?.predeployed,
+        hasActiveSessionKey: raw?.hasActiveSessionKey
+      });
+      return {
+        predeployed: raw?.predeployed,
+        hasActiveSessionKey: raw?.hasActiveSessionKey
+      };
+    } catch (error) {
+      console.warn(
+        "[zyfai] getPositions wallet-state read failed (non-fatal):",
+        error instanceof Error ? error.message : String(error)
+      );
+      return {};
+    }
+  }
   async isPredeployedPoolWallet(ownerAddress, smartWallet) {
+    const { predeployed } = await this.readWalletState(ownerAddress);
+    if (typeof predeployed === "boolean") {
+      debugLog(
+        "zyfai:onboard",
+        `wallet class: ${predeployed ? "PREDEPLOYED (new flow)" : "OLD (legacy flow)"}`,
+        { source: "getPositions.predeployed", predeployed }
+      );
+      return predeployed;
+    }
+    const internals = this.sdk;
+    if (typeof internals.isPredeployed === "boolean") {
+      debugLog(
+        "zyfai:onboard",
+        `wallet class: ${internals.isPredeployed ? "PREDEPLOYED (new flow)" : "OLD (legacy flow)"}`,
+        {
+          source: "login response (cached)",
+          predeployed: internals.isPredeployed
+        }
+      );
+      return internals.isPredeployed;
+    }
     try {
       const byEoa = await this.sdk.getSmartWalletByEOA(ownerAddress);
-      return typeof byEoa?.smartWallet === "string" && byEoa.smartWallet.toLowerCase() === smartWallet.toLowerCase();
+      const isPool = typeof byEoa?.smartWallet === "string" && byEoa.smartWallet.toLowerCase() === smartWallet.toLowerCase();
+      debugLog(
+        "zyfai:onboard",
+        `wallet class: ${isPool ? "PREDEPLOYED (new flow)" : "OLD (legacy flow)"}`,
+        {
+          source: "getSmartWalletByEOA fallback",
+          poolRecord: byEoa?.smartWallet
+        }
+      );
+      return isPool;
     } catch (error) {
       console.warn(
         "[zyfai] getSmartWalletByEOA failed; assuming a legacy wallet:",
@@ -1344,8 +1414,24 @@ var ZyfaiAgent = class {
         ownerAddress,
         chainId
       );
-      if (!wallet.isDeployed) return;
-      await this.ensureSessionKey(ownerAddress, chainId, wallet.address);
+      debugLog("zyfai:onboard", `activation check on chain ${chainId}`, {
+        smartWallet: wallet.address,
+        isDeployed: wallet.isDeployed
+      });
+      if (!wallet.isDeployed) {
+        debugLog(
+          "zyfai:onboard",
+          "Safe not deployed on this chain; activation does nothing (deposit owns deploys)"
+        );
+        return;
+      }
+      const { hasActiveSessionKey } = await this.readWalletState(ownerAddress);
+      await this.ensureSessionKey(
+        ownerAddress,
+        chainId,
+        wallet.address,
+        hasActiveSessionKey
+      );
     } catch (error) {
       console.warn(
         "[zyfai] session-key check at activation failed (non-fatal):",
@@ -1353,20 +1439,51 @@ var ZyfaiAgent = class {
       );
     }
   }
-  async ensureSessionKey(ownerAddress, chainId, smartWallet) {
+  async ensureSessionKey(ownerAddress, chainId, smartWallet, hasActiveSessionKey) {
+    const attemptKey = `${ownerAddress.toLowerCase()}:${chainId}`;
+    if (this.sessionKeyAttempts.has(attemptKey)) {
+      debugLog(
+        "zyfai:onboard",
+        "session key: already attempted this session, skipping",
+        { chainId }
+      );
+      return;
+    }
     try {
-      const installed = await this.getPublicClient(chainId).readContract({
-        address: smartWallet,
-        abi: ERC7579_IS_MODULE_INSTALLED_ABI,
-        functionName: "isModuleInstalled",
-        // moduleTypeId 1 = validator (ERC-7579)
-        args: [1n, SMART_SESSIONS_VALIDATOR, "0x"]
-      });
-      if (installed) return;
+      if (hasActiveSessionKey === true) {
+        debugLog(
+          "zyfai:onboard",
+          "session key: already on record -> nothing to do",
+          { chainId }
+        );
+        return;
+      }
+      if (hasActiveSessionKey === void 0) {
+        const installed = await this.readSmartSessionsInstalled(
+          chainId,
+          smartWallet
+        );
+        debugLog(
+          "zyfai:onboard",
+          `session key: Zyfai state unavailable; on-chain validator ${installed ? "INSTALLED" : "MISSING"}`,
+          { smartWallet, chainId }
+        );
+        if (installed) return;
+      }
+      this.sessionKeyAttempts.add(attemptKey);
       console.warn(
-        `[zyfai] Safe ${smartWallet} has no smart-sessions validator on chain ${chainId}; creating a session key so the agent can allocate.`
+        `[zyfai] no session key for ${smartWallet} on chain ${chainId}; creating one so the agent can allocate.`
       );
+      debugLog("zyfai:onboard", "session key: calling createSessionKey", {
+        chainId,
+        smartWallet,
+        hasActiveSessionKey
+      });
       await this.sdk.createSessionKey(ownerAddress, chainId);
+      debugLog("zyfai:onboard", "session key: createSessionKey succeeded", {
+        chainId,
+        smartWallet
+      });
     } catch (error) {
       console.warn(
         "[zyfai] createSessionKey skipped (non-fatal):",
@@ -1374,6 +1491,16 @@ var ZyfaiAgent = class {
       );
     }
   }
+  /** Ground truth for "can Zyfai's automation act on this Safe, on this chain". */
+  async readSmartSessionsInstalled(chainId, smartWallet) {
+    return this.getPublicClient(chainId).readContract({
+      address: smartWallet,
+      abi: ERC7579_IS_MODULE_INSTALLED_ABI,
+      functionName: "isModuleInstalled",
+      // moduleTypeId 1 = validator (ERC-7579)
+      args: [1n, SMART_SESSIONS_VALIDATOR, "0x"]
+    });
+  }
   /**
    * Guarantee the user's Safe has code on `chainId` before anything transfers
    * funds into it, and return its address.
@@ -1394,8 +1521,24 @@ var ZyfaiAgent = class {
    */
   async ensureWalletDeployed(ownerAddress, chainId) {
     const wallet = await this.sdk.getSmartWalletAddress(ownerAddress, chainId);
+    debugLog("zyfai:onboard", `--- deposit onboarding, chain ${chainId} ---`, {
+      eoa: ownerAddress,
+      smartWallet: wallet.address,
+      isDeployed: wallet.isDeployed,
+      isOwner: wallet.isOwner
+    });
     if (wallet.isDeployed) {
-      await this.ensureSessionKey(ownerAddress, chainId, wallet.address);
+      debugLog(
+        "zyfai:onboard",
+        "Safe already has code -> no deploy needed, checking the session key"
+      );
+      const { hasActiveSessionKey } = await this.readWalletState(ownerAddress);
+      await this.ensureSessionKey(
+        ownerAddress,
+        chainId,
+        wallet.address,
+        hasActiveSessionKey
+      );
       return wallet.address;
     }
     const poolFirst = await this.isPredeployedPoolWallet(
@@ -1411,14 +1554,27 @@ var ZyfaiAgent = class {
       this.sdk.deploySafe(ownerAddress, chainId, "aggressive", true)
     );
     const [first, second] = poolFirst ? [deployAsPool, deployAsLegacy] : [deployAsLegacy, deployAsPool];
+    debugLog(
+      "zyfai:onboard",
+      `Safe has no code on chain ${chainId} -> deploying via ${poolFirst ? "deployOnChains (pool path)" : "deploySafe(createSessionKey=true) (legacy path)"}`
+    );
     try {
       await first();
+      debugLog(
+        "zyfai:onboard",
+        `${poolFirst ? "deployOnChains" : "deploySafe"} succeeded`
+      );
     } catch (error) {
       console.warn(
         `[zyfai] ${poolFirst ? "deployOnChains" : "deploySafe"} failed on chain ${chainId}; trying the other deploy path:`,
         error instanceof Error ? error.message : String(error)
       );
+      debugLog(
+        "zyfai:onboard",
+        `falling back to ${poolFirst ? "deploySafe (legacy path)" : "deployOnChains (pool path)"}`
+      );
       await second();
+      debugLog("zyfai:onboard", "fallback deploy path succeeded");
     }
     const redeployed = await this.sdk.getSmartWalletAddress(
       ownerAddress,
@@ -1883,12 +2039,9 @@ async function postSponsorTransferAuth(input) {
       {
         statusCode: res.status,
         responseBody: text.slice(0, 500),
-        // A 4xx is an explicit refusal before execution (DTO validation,
-        // signature rejection, simulation) — nothing was broadcast, so a
-        // user-paid retry cannot double-spend. 503 SPONSOR_UNAVAILABLE means
-        // the relayer was out of gas, also pre-broadcast. Any other 5xx stays
-        // ambiguous: the transfer may already be in flight.
-        safeToFallback: res.status >= 400 && res.status < 500 || res.status === 503
+        // 503 SPONSOR_UNAVAILABLE = relayer out of gas; the tx was rejected
+        // before broadcast, so it is safe to fall back to a user-paid deposit.
+        safeToFallback: res.status === 503
       }
     );
   }
@@ -2160,9 +2313,9 @@ function makeSponsoredDepositCallback(deps) {
   };
 }
 
-// src/lib/sponsored-permit2-deposit.ts
+// src/lib/sponsored-weth-deposit.ts
 var PERMIT_WINDOW_SECONDS = 15 * 60;
-function makeSponsoredPermit2Callback(deps) {
+function makeSponsoredWethCallback(deps) {
   const get = deps.httpGet ?? getSponsorRelayerAddress;
   const post = deps.httpPost ?? postSponsorPermit2Transfer;
   return async (smartWallet, chainId, amount) => {
@@ -2171,7 +2324,7 @@ function makeSponsoredPermit2Callback(deps) {
     if (!token) {
       throw new OwneyError(
         "CHAIN_UNSUPPORTED",
-        `No sponsored ${deps.assetLabel} configured for chain ${chainId}`
+        `No sponsored WETH configured for chain ${chainId}`
       );
     }
     const amountWei = BigInt(amount);
@@ -2183,14 +2336,14 @@ function makeSponsoredPermit2Callback(deps) {
       if (balance < amountWei) {
         throw new OwneyError(
           "DEPOSIT_INSUFFICIENT_BALANCE",
-          `Insufficient ${deps.assetLabel} balance for this deposit.`,
+          "Insufficient WETH balance for this deposit.",
           { token, chainId: cid, balance: balance.toString(), amount }
         );
       }
     } catch (err) {
       if (err instanceof OwneyError) throw err;
       console.warn(
-        `[owney-sdk] ${deps.assetLabel} balance pre-check failed (non-fatal):`,
+        "[owney-sdk] WETH balance pre-check failed (non-fatal):",
         err instanceof Error ? err.message : String(err)
       );
     }
@@ -2198,7 +2351,7 @@ function makeSponsoredPermit2Callback(deps) {
     if (allowance < amountWei) {
       throw new OwneyError(
         "PERMIT2_APPROVAL_REQUIRED",
-        `${deps.assetLabel} gasless deposits need a one-time Permit2 approval; call approvePermit2("${deps.assetLabel}") first`,
+        "WETH gasless deposits need a one-time Permit2 approval; call approvePermit2() first",
         { token, chainId: cid, allowance: allowance.toString(), amount }
       );
     }
@@ -2279,8 +2432,6 @@ var SPONSORED_WETH_BY_CHAIN = {
   42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
   1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 };
-var PERMIT2_ALLOWANCE_POLL_MAX_ATTEMPTS = 10;
-var PERMIT2_ALLOWANCE_POLL_INTERVAL_MS = 1500;
 function shouldFallbackToUserPaid(error, asset, appCallback) {
   return (asset === "WETH" || asset === "USDC") && appCallback === void 0 && error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED" && error.details?.safeToFallback === true;
 }
@@ -2305,7 +2456,7 @@ var OwneySDK = class {
   routingApiBaseUrl;
   referralSource;
   cachedSponsoredCallback = null;
-  cachedPermit2Callbacks = /* @__PURE__ */ new Map();
+  cachedWethSponsoredCallback = null;
   initializingAgentsPromise = null;
   constructor(config) {
     this.apiKey = config.apiKey;
@@ -2333,7 +2484,7 @@ var OwneySDK = class {
     }
     this.state = { provider, walletAddress, chainId: null };
     this.cachedSponsoredCallback = null;
-    this.cachedPermit2Callbacks.clear();
+    this.cachedWethSponsoredCallback = null;
   }
   /**
    * Disconnect from all agents and clear connection state.
@@ -2347,7 +2498,7 @@ var OwneySDK = class {
     this.disabledAgents.clear();
     this.state = null;
     this.cachedSponsoredCallback = null;
-    this.cachedPermit2Callbacks.clear();
+    this.cachedWethSponsoredCallback = null;
   }
   isAgentDisabled(agentId) {
     return this.disabledAgents.has(agentId);
@@ -2424,23 +2575,25 @@ var OwneySDK = class {
     return callback;
   }
   /**
-   * Lazily builds (and caches) the Permit2 sponsored callback for one asset.
-   * Used for WETH always, and for USDC when the connected owner is a smart
-   * account — EIP-3009 verifies with ecrecover inside USDC and cannot accept a
-   * contract signature, while Permit2 supports ERC-1271.
+   * Lazily builds (and caches) the default Permit2 sponsored WETH deposit
+   * callback used when the caller omits `depositCallback` for a WETH
+   * deposit. Mirrors `getDefaultSponsoredCallback()` but signs a Permit2
+   * `PermitTransferFrom` instead of an EIP-3009 authorization.
    */
-  getDefaultPermit2Callback(asset, onApproved) {
-    const cached = this.cachedPermit2Callbacks.get(asset);
-    if (!onApproved && cached) return cached;
+  getDefaultWethSponsoredCallback(onApproved) {
+    if (!onApproved && this.cachedWethSponsoredCallback)
+      return this.cachedWethSponsoredCallback;
     const provider = this.requireConnectedProvider();
     const owner = this.state.walletAddress;
-    const callback = makeSponsoredPermit2Callback({
+    const callback = makeSponsoredWethCallback({
       apiKey: this.apiKey,
       baseUrl: this.routingApiBaseUrl,
       ownerAddress: owner,
-      assetLabel: asset,
       onApproved,
-      tokenAddressByChain: asset === "USDC" ? SPONSORED_USDC_BY_CHAIN : SPONSORED_WETH_BY_CHAIN,
+      tokenAddressByChain: SPONSORED_WETH_BY_CHAIN,
+      // Casts work around viem's chain-narrowed Client vs the generic
+      // PublicClient/WalletClient param types — structurally identical at
+      // runtime, but the two share a name TS treats as unrelated.
       getPublicClient: (cid) => createPublicClient2({
         chain: VIEM_CHAIN2[cid],
         transport: custom(provider)
@@ -2451,34 +2604,9 @@ var OwneySDK = class {
         transport: custom(provider)
       })
     });
-    if (!onApproved) this.cachedPermit2Callbacks.set(asset, callback);
+    if (!onApproved) this.cachedWethSponsoredCallback = callback;
     return callback;
   }
-  /**
-   * True when the connected owner has bytecode — a deployed smart wallet, or an
-   * EOA carrying an EIP-7702 delegation (the Base app's "Upgrade your wallet").
-   * Such wallets sign via ERC-1271, which EIP-3009 cannot verify.
-   *
-   * Fails OPEN: an unreadable code check returns false so a working EOA deposit
-   * is never blocked by a flaky provider.
-   */
-  async ownerHasCode() {
-    try {
-      const provider = this.requireConnectedProvider();
-      const code = await provider.request({
-        method: "eth_getCode",
-        params: [this.state.walletAddress, "latest"]
-      });
-      return Boolean(code) && code !== "0x";
-    } catch (error) {
-      debugLog(
-        "deposit",
-        "owner code check failed; assuming EOA",
-        error instanceof Error ? error.message : String(error)
-      );
-      return false;
-    }
-  }
   getAgent(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) {
@@ -2674,11 +2802,7 @@ var OwneySDK = class {
     }
     const state = this.requireState();
     const chainId = this.requireChainId();
-    const ownerIsSmartAccount = depositCallback === void 0 && asset !== "WETH" ? await this.ownerHasCode() : false;
-    const effectiveCallback = depositCallback ?? (asset === "WETH" || ownerIsSmartAccount ? this.getDefaultPermit2Callback(
-      asset === "WETH" ? "WETH" : "USDC",
-      onApproved
-    ) : this.getDefaultSponsoredCallback(onApproved));
+    const effectiveCallback = depositCallback ?? (asset === "WETH" ? this.getDefaultWethSponsoredCallback(onApproved) : this.getDefaultSponsoredCallback(onApproved));
     if (agentId) {
       if (this.isAgentDisabled(agentId)) {
         throw new OwneyError(
@@ -2747,16 +2871,13 @@ var OwneySDK = class {
    * 1. Missing Permit2 allowance: when the app did not supply its own
    *    callback and the attempt fails with `PERMIT2_APPROVAL_REQUIRED` on a
    *    WETH deposit, this is the wallet's first gasless WETH deposit. We send
-   *    the one-time (user-paid) Permit2 approval via `approvePermit2()`, wait
-   *    for the new allowance to actually be readable via
-   *    `waitForPermit2Allowance()` (the wallet's own RPC can lag a freshly
-   *    mined tx), then 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. the user rejects the wallet prompt), that error
-   *    propagates as-is — the user said no to a transaction, so we must not
-   *    turn around and ask them to pay for a different one via the fallback
-   *    below.
+   *    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.
+   *    the user rejects the wallet prompt), that error propagates as-is —
+   *    the user said no to a transaction, so we must not turn around and ask
+   *    them to pay for a different one via the fallback below.
    * 2. `shouldFallbackToUserPaid`: the SDK's own WETH sponsor path failed at
    *    the infrastructure layer in a provably safe-to-retry way, so we warn
    *    and retry once with `undefined`, falling through to a user-paid
@@ -2768,49 +2889,6 @@ var OwneySDK = class {
    * propagates unchanged. Scoped per agent invocation so one agent's failure
    * doesn't force a retry of sibling agents in a multi-agent split.
    */
-  /**
-   * Polls the owner's Permit2 allowance for `asset` until it covers `amount`
-   * or the attempt budget runs out. Called right after `approvePermit2()`
-   * resolves: the approval tx is mined, but the wallet's own RPC can still
-   * serve a stale (zero) allowance on the very next read (replica lag), which
-   * would otherwise make the immediate retry fail with the same
-   * PERMIT2_APPROVAL_REQUIRED error the user just approved past. Never
-   * throws — if the allowance still hasn't caught up after the budget, the
-   * caller's retry will surface the honest PERMIT2_APPROVAL_REQUIRED error
-   * rather than this helper inventing a different one.
-   */
-  async waitForPermit2Allowance(asset, amount) {
-    const state = this.requireState();
-    const chainId = this.requireChainId();
-    const provider = this.requireConnectedProvider();
-    const token = asset === "USDC" ? SPONSORED_USDC_BY_CHAIN[chainId] : SPONSORED_WETH_BY_CHAIN[chainId];
-    if (!token) return;
-    const publicClient = createPublicClient2({
-      chain: VIEM_CHAIN2[chainId],
-      transport: custom(provider)
-    });
-    for (let attempt = 0; attempt < PERMIT2_ALLOWANCE_POLL_MAX_ATTEMPTS; attempt++) {
-      if (attempt > 0) {
-        await new Promise(
-          (resolve) => setTimeout(resolve, PERMIT2_ALLOWANCE_POLL_INTERVAL_MS)
-        );
-      }
-      try {
-        const allowance = await readPermit2Allowance(
-          publicClient,
-          token,
-          state.walletAddress
-        );
-        if (allowance >= amount) return;
-      } catch (error) {
-        debugLog(
-          "deposit",
-          "Permit2 allowance poll read failed; retrying",
-          error instanceof Error ? error.message : String(error)
-        );
-      }
-    }
-  }
   async depositWithFallback(agent, state, chainId, amount, asset, effectiveCallback, appCallback) {
     const attempt = (callback) => withFailureReporting(
       this.apiKey,
@@ -2828,16 +2906,12 @@ var OwneySDK = class {
       try {
         return await attempt(effectiveCallback);
       } catch (error) {
-        if (!approvalAttempted && appCallback === void 0 && (asset === "WETH" || asset === "USDC") && error instanceof OwneyError && error.code === "PERMIT2_APPROVAL_REQUIRED") {
+        if (!approvalAttempted && appCallback === void 0 && asset === "WETH" && error instanceof OwneyError && error.code === "PERMIT2_APPROVAL_REQUIRED") {
           approvalAttempted = true;
           console.warn(
-            `[owney-sdk] First ${asset} gasless deposit: sending one-time Permit2 approval...`
-          );
-          await this.approvePermit2(asset);
-          await this.waitForPermit2Allowance(
-            asset,
-            BigInt(amount)
+            "[owney-sdk] First WETH deposit: sending one-time Permit2 approval..."
           );
+          await this.approvePermit2();
           continue;
         }
         if (!shouldFallbackToUserPaid(error, asset, appCallback)) throw error;
@@ -3351,32 +3425,23 @@ var OwneySDK = class {
     return agent.ensureAutoSelectProtocols(state, chainId, asset);
   }
   /**
-   * One-time, user-paid approval of Permit2 on the given sponsored token for
-   * the active chain. Required once per wallet per chain per token before a
-   * gasless deposit of that asset over Permit2; afterwards deposit() is
-   * signature-only for it. This call itself is a real transaction the user
-   * pays gas for. Resolves only after the approval transaction is mined (1
-   * confirmation), so a subsequent deposit() will see the new allowance;
-   * throws if the transaction reverted.
+   * One-time, user-paid approval of Permit2 on the sponsored WETH token for
+   * the active chain. Required once per wallet per chain before gasless WETH
+   * deposits; afterwards deposit() is signature-only. Resolves only after the
+   * approval transaction is mined (1 confirmation), so a subsequent deposit()
+   * will see the new allowance; throws if the transaction reverted.
    * @returns the approval transaction hash.
    */
   async approvePermit2(asset = "WETH") {
+    void asset;
     const state = this.requireState();
     const chainId = this.requireChainId();
-    let guard = this.agents.get("zyfai");
-    if (!guard) {
-      try {
-        guard = this.getEligibleAgents(chainId, asset)[0];
-      } catch {
-        guard = void 0;
-      }
-    }
-    if (guard) this.validateAssetSupport(guard, chainId, asset);
-    const token = asset === "USDC" ? SPONSORED_USDC_BY_CHAIN[chainId] : SPONSORED_WETH_BY_CHAIN[chainId];
+    this.validateAssetSupport(this.getAgent("zyfai"), chainId, "WETH");
+    const token = SPONSORED_WETH_BY_CHAIN[chainId];
     if (!token) {
       throw new OwneyError(
         "CHAIN_UNSUPPORTED",
-        `No sponsored ${asset} on chain ${chainId}`
+        `No sponsored WETH on chain ${chainId}`
       );
     }
     const provider = this.requireConnectedProvider();