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

package/dist/index.cjs

@@ -2308,6 +2308,8 @@ 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;
 }
@@ -2774,13 +2776,16 @@ 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()` 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.
+   *    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.
    * 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
@@ -2792,6 +2797,49 @@ 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 = (0, import_viem5.createPublicClient)({
+      chain: VIEM_CHAIN2[chainId],
+      transport: (0, import_viem5.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,
@@ -2815,6 +2863,10 @@ var OwneySDK = class {
             `[owney-sdk] First ${asset} gasless deposit: sending one-time Permit2 approval...`
           );
           await this.approvePermit2(asset);
+          await this.waitForPermit2Allowance(
+            asset,
+            BigInt(amount)
+          );
           continue;
         }
         if (!shouldFallbackToUserPaid(error, asset, appCallback)) throw error;

package/dist/index.d.cts

@@ -492,13 +492,16 @@ 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()` 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.
+     *    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.
      * 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
@@ -510,6 +513,18 @@ 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;

package/dist/index.d.ts

@@ -492,13 +492,16 @@ 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()` 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.
+     *    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.
      * 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
@@ -510,6 +513,18 @@ 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;

package/dist/index.js

@@ -2279,6 +2279,8 @@ 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;
 }
@@ -2745,13 +2747,16 @@ 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()` 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.
+   *    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.
    * 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
@@ -2763,6 +2768,49 @@ 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,
@@ -2786,6 +2834,10 @@ var OwneySDK = class {
             `[owney-sdk] First ${asset} gasless deposit: sending one-time Permit2 approval...`
           );
           await this.approvePermit2(asset);
+          await this.waitForPermit2Allowance(
+            asset,
+            BigInt(amount)
+          );
           continue;
         }
         if (!shouldFallbackToUserPaid(error, asset, appCallback)) throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owney/sdk",
-  "version": "0.7.7-beta.0",
+  "version": "0.7.7-beta.2",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",