thirdweb 5.116.0 → 5.116.1

package/dist/types/react/core/hooks/x402/useFetchWithPaymentCore.d.ts

@@ -1,4 +1,5 @@
 import type { ThirdwebClient } from "../../../../client/client.js";
+import type { AsyncStorage } from "../../../../utils/storage/AsyncStorage.js";
 import type { Wallet } from "../../../../wallets/interfaces/wallet.js";
 import type { RequestedPaymentRequirements } from "../../../../x402/schemas.js";
 import type { PaymentRequiredResult } from "../../../../x402/types.js";
@@ -6,6 +7,11 @@ export type UseFetchWithPaymentOptions = {
     maxValue?: bigint;
     paymentRequirementsSelector?: (paymentRequirements: RequestedPaymentRequirements[]) => RequestedPaymentRequirements | undefined;
     parseAs?: "json" | "text" | "raw";
+    /**
+     * Storage for caching permit signatures (for "upto" scheme).
+     * When provided, permit signatures will be cached and reused if the on-chain allowance is sufficient.
+     */
+    storage?: AsyncStorage;
 };
 type ShowErrorModalCallback = (data: {
     errorData: PaymentRequiredResult["responseBody"];

package/dist/types/react/core/hooks/x402/useFetchWithPaymentCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFetchWithPaymentCore.d.ts","sourceRoot":"","sources":["../../../../../../src/react/core/hooks/x402/useFetchWithPaymentCore.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;AAEvE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAC;AAChF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGvE,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2BAA2B,CAAC,EAAE,CAC5B,mBAAmB,EAAE,4BAA4B,EAAE,KAChD,4BAA4B,GAAG,SAAS,CAAC;IAC9C,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;CACnC,CAAC;AAEF,KAAK,sBAAsB,GAAG,CAAC,IAAI,EAAE;IACnC,SAAS,EAAE,qBAAqB,CAAC,cAAc,CAAC,CAAC;IACjD,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,KAAK,IAAI,CAAC;AAEX,KAAK,wBAAwB,GAAG,CAAC,IAAI,EAAE;IACrC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,KAAK,IAAI,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,0BAA0B,EACpC,cAAc,CAAC,EAAE,sBAAsB,EACvC,gBAAgB,CAAC,EAAE,wBAAwB;;;;;;;;;;eAShC,WAAW;eACX,WAAW;;;;;;;;;eADX,WAAW;eACX,WAAW;;8BA+FY,WAAW,SAAS,WAAW;;;;eAhGtD,WAAW;eACX,WAAW;;;;;;;;;eADX,WAAW;eACX,WAAW;;;;;;;;;eADX,WAAW;eACX,WAAW;;8BA+FY,WAAW,SAAS,WAAW;;;;;eAhGtD,WAAW;eACX,WAAW;;;;;;;;eADX,WAAW;eACX,WAAW;;;;;;;;;eADX,WAAW;eACX,WAAW;;8BA+FY,WAAW,SAAS,WAAW;;;;;eAhGtD,WAAW;eACX,WAAW;;;;;;;;eADX,WAAW;eACX,WAAW;;;;;;;;;eADX,WAAW;eACX,WAAW;;8BA+FY,WAAW,SAAS,WAAW;EAKlE"}
+{"version":3,"file":"useFetchWithPaymentCore.d.ts","sourceRoot":"","sources":["../../../../../../src/react/core/hooks/x402/useFetchWithPaymentCore.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AAC9E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;AAEvE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAC;AAChF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGvE,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2BAA2B,CAAC,EAAE,CAC5B,mBAAmB,EAAE,4BAA4B,EAAE,KAChD,4BAA4B,GAAG,SAAS,CAAC;IAC9C,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;IAClC;;;OAGG;IACH,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB,CAAC;AAEF,KAAK,sBAAsB,GAAG,CAAC,IAAI,EAAE;IACnC,SAAS,EAAE,qBAAqB,CAAC,cAAc,CAAC,CAAC;IACjD,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,KAAK,IAAI,CAAC;AAEX,KAAK,wBAAwB,GAAG,CAAC,IAAI,EAAE;IACrC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,KAAK,IAAI,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,0BAA0B,EACpC,cAAc,CAAC,EAAE,sBAAsB,EACvC,gBAAgB,CAAC,EAAE,wBAAwB;;;;;;;;;;eAShC,WAAW;eACX,WAAW;;;;;;;;;eADX,WAAW;eACX,WAAW;;8BAmGY,WAAW,SAAS,WAAW;;;;eApGtD,WAAW;eACX,WAAW;;;;;;;;;eADX,WAAW;eACX,WAAW;;;;;;;;;eADX,WAAW;eACX,WAAW;;8BAmGY,WAAW,SAAS,WAAW;;;;;eApGtD,WAAW;eACX,WAAW;;;;;;;;eADX,WAAW;eACX,WAAW;;;;;;;;;eADX,WAAW;eACX,WAAW;;8BAmGY,WAAW,SAAS,WAAW;;;;;eApGtD,WAAW;eACX,WAAW;;;;;;;;eADX,WAAW;eACX,WAAW;;;;;;;;;eADX,WAAW;eACX,WAAW;;8BAmGY,WAAW,SAAS,WAAW;EAKlE"}

package/dist/types/react/native/hooks/x402/useFetchWithPayment.d.ts

@@ -22,6 +22,7 @@ export type { UseFetchWithPaymentOptions };
  * @param options.maxValue - The maximum allowed payment amount in base units
  * @param options.paymentRequirementsSelector - Custom function to select payment requirements from available options
  * @param options.parseAs - How to parse the response: "json" (default), "text", or "raw"
+ * @param options.storage - Storage for caching permit signatures (for "upto" scheme). Provide your own AsyncStorage implementation for React Native.
  * @returns An object containing:
  * - `fetchWithPayment`: Function to make fetch requests with automatic payment handling (returns parsed data)
  * - `isPending`: Boolean indicating if a request is in progress

package/dist/types/react/native/hooks/x402/useFetchWithPayment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFetchWithPayment.d.ts","sourceRoot":"","sources":["../../../../../../src/react/native/hooks/x402/useFetchWithPayment.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EACL,KAAK,0BAA0B,EAEhC,MAAM,qDAAqD,CAAC;AAE7D,YAAY,EAAE,0BAA0B,EAAE,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIrC"}
+{"version":3,"file":"useFetchWithPayment.d.ts","sourceRoot":"","sources":["../../../../../../src/react/native/hooks/x402/useFetchWithPayment.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,OAAO,EACL,KAAK,0BAA0B,EAEhC,MAAM,qDAAqD,CAAC;AAE7D,YAAY,EAAE,0BAA0B,EAAE,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOrC"}

package/dist/types/react/web/hooks/x402/useFetchWithPayment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFetchWithPayment.d.ts","sourceRoot":"","sources":["../../../../../../src/react/web/hooks/x402/useFetchWithPayment.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sCAAsC,CAAC;AAClE,OAAO,EACL,KAAK,0BAA0B,EAEhC,MAAM,qDAAqD,CAAC;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EACL,KAAK,sBAAsB,EAE5B,MAAM,2CAA2C,CAAC;AAInD,YAAY,EAAE,0BAA0B,EAAE,CAAC;AAE3C,KAAK,yBAAyB,GAAG,0BAA0B,GAAG;IAC5D;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,CAAC;IACjC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CACzB,IAAI,CACF,cAAc,EACd,QAAQ,GAAG,OAAO,GAAG,cAAc,GAAG,WAAW,GAAG,UAAU,GAAG,OAAO,CACzE,CACF,CAAC;IACF;;;OAGG;IACH,cAAc,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC;IAClE;;OAEG;IACH,mBAAmB,CAAC,EAAE;QACpB,wCAAwC;QACxC,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,8BAA8B;QAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,0CAA0C;QAC1C,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2HG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4EpC"}
+{"version":3,"file":"useFetchWithPayment.d.ts","sourceRoot":"","sources":["../../../../../../src/react/web/hooks/x402/useFetchWithPayment.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAGnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sCAAsC,CAAC;AAClE,OAAO,EACL,KAAK,0BAA0B,EAEhC,MAAM,qDAAqD,CAAC;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EACL,KAAK,sBAAsB,EAE5B,MAAM,2CAA2C,CAAC;AAInD,YAAY,EAAE,0BAA0B,EAAE,CAAC;AAE3C,KAAK,yBAAyB,GAAG,0BAA0B,GAAG;IAC5D;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,CAAC;IACjC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CACzB,IAAI,CACF,cAAc,EACd,QAAQ,GAAG,OAAO,GAAG,cAAc,GAAG,WAAW,GAAG,UAAU,GAAG,OAAO,CACzE,CACF,CAAC;IACF;;;OAGG;IACH,cAAc,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC;IAClE;;OAEG;IACH,mBAAmB,CAAC,EAAE;QACpB,wCAAwC;QACxC,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,8BAA8B;QAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,0CAA0C;QAC1C,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2HG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqFpC"}

package/dist/types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.116.0";
+export declare const version = "5.116.1";
 //# sourceMappingURL=version.d.ts.map

package/dist/types/x402/fetchWithPayment.d.ts

@@ -1,4 +1,5 @@
 import type { ThirdwebClient } from "../client/client.js";
+import type { AsyncStorage } from "../utils/storage/AsyncStorage.js";
 import type { Wallet } from "../wallets/interfaces/wallet.js";
 import { type RequestedPaymentRequirements } from "./schemas.js";
 /**
@@ -43,5 +44,10 @@ import { type RequestedPaymentRequirements } from "./schemas.js";
 export declare function wrapFetchWithPayment(fetch: typeof globalThis.fetch, client: ThirdwebClient, wallet: Wallet, options?: {
     maxValue?: bigint;
     paymentRequirementsSelector?: (paymentRequirements: RequestedPaymentRequirements[]) => RequestedPaymentRequirements | undefined;
+    /**
+     * Storage for caching permit signatures (for "upto" scheme).
+     * When provided, permit signatures will be cached and reused if the on-chain allowance is sufficient.
+     */
+    storage?: AsyncStorage;
 }): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
 //# sourceMappingURL=fetchWithPayment.d.ts.map

package/dist/types/x402/fetchWithPayment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchWithPayment.d.ts","sourceRoot":"","sources":["../../../src/x402/fetchWithPayment.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAGL,KAAK,4BAA4B,EAElC,MAAM,cAAc,CAAC;AAGtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,EAC9B,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2BAA2B,CAAC,EAAE,CAC5B,mBAAmB,EAAE,4BAA4B,EAAE,KAChD,4BAA4B,GAAG,SAAS,CAAC;CAC/C,IAEa,OAAO,WAAW,EAAE,OAAO,WAAW,uBA6FrD"}
+{"version":3,"file":"fetchWithPayment.d.ts","sourceRoot":"","sources":["../../../src/x402/fetchWithPayment.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAE9D,OAAO,EAGL,KAAK,4BAA4B,EAElC,MAAM,cAAc,CAAC;AAGtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,EAC9B,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2BAA2B,CAAC,EAAE,CAC5B,mBAAmB,EAAE,4BAA4B,EAAE,KAChD,4BAA4B,GAAG,SAAS,CAAC;IAC9C;;;OAGG;IACH,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB,IAEa,OAAO,WAAW,EAAE,OAAO,WAAW,uBAyGrD"}

package/dist/types/x402/permitSignatureStorage.d.ts

@@ -0,0 +1,43 @@
+import type { AsyncStorage } from "../utils/storage/AsyncStorage.js";
+import type { RequestedPaymentPayload } from "./schemas.js";
+/**
+ * Cached permit signature data structure
+ */
+type CachedPermitSignature = {
+    payload: RequestedPaymentPayload;
+    deadline: string;
+    maxAmount: string;
+};
+/**
+ * Parameters for generating a permit cache key
+ */
+export type PermitCacheKeyParams = {
+    chainId: number;
+    asset: string;
+    owner: string;
+    spender: string;
+};
+/**
+ * Retrieves a cached permit signature from storage
+ * @param storage - The AsyncStorage instance to use
+ * @param params - The parameters identifying the cached signature
+ * @returns The cached signature data or null if not found
+ */
+export declare function getPermitSignatureFromCache(storage: AsyncStorage, params: PermitCacheKeyParams): Promise<CachedPermitSignature | null>;
+/**
+ * Saves a permit signature to storage cache
+ * @param storage - The AsyncStorage instance to use
+ * @param params - The parameters identifying the signature
+ * @param payload - The signed payment payload to cache
+ * @param deadline - The deadline timestamp of the permit
+ * @param maxAmount - The maximum amount authorized
+ */
+export declare function savePermitSignatureToCache(storage: AsyncStorage, params: PermitCacheKeyParams, payload: RequestedPaymentPayload, deadline: string, maxAmount: string): Promise<void>;
+/**
+ * Clears a cached permit signature from storage
+ * @param storage - The AsyncStorage instance to use
+ * @param params - The parameters identifying the cached signature
+ */
+export declare function clearPermitSignatureFromCache(storage: AsyncStorage, params: PermitCacheKeyParams): Promise<void>;
+export {};
+//# sourceMappingURL=permitSignatureStorage.d.ts.map

package/dist/types/x402/permitSignatureStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permitSignatureStorage.d.ts","sourceRoot":"","sources":["../../../src/x402/permitSignatureStorage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE5D;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC3B,OAAO,EAAE,uBAAuB,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAaF;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAWvC;AAED;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,uBAAuB,EAChC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAOf"}

package/dist/types/x402/sign.d.ts

@@ -1,4 +1,5 @@
 import type { ThirdwebClient } from "../client/client.js";
+import type { AsyncStorage } from "../utils/storage/AsyncStorage.js";
 import type { Account } from "../wallets/interfaces/wallet.js";
 import { type RequestedPaymentRequirements } from "./schemas.js";
 /**
@@ -7,7 +8,8 @@ import { type RequestedPaymentRequirements } from "./schemas.js";
  * @param client - The signer wallet instance used to create the payment header
  * @param x402Version - The version of the X402 protocol to use
  * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @param storage - Optional storage for caching permit signatures (for "upto" scheme)
  * @returns A promise that resolves to the encoded payment header string
  */
-export declare function createPaymentHeader(client: ThirdwebClient, account: Account, paymentRequirements: RequestedPaymentRequirements, x402Version: number): Promise<string>;
+export declare function createPaymentHeader(client: ThirdwebClient, account: Account, paymentRequirements: RequestedPaymentRequirements, x402Version: number, storage?: AsyncStorage): Promise<string>;
 //# sourceMappingURL=sign.d.ts.map

package/dist/types/x402/sign.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sign.d.ts","sourceRoot":"","sources":["../../../src/x402/sign.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAK1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAG/D,OAAO,EAIL,KAAK,4BAA4B,EAElC,MAAM,cAAc,CAAC;AAoItB;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,OAAO,EAChB,mBAAmB,EAAE,4BAA4B,EACjD,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,CAQjB"}
+{"version":3,"file":"sign.d.ts","sourceRoot":"","sources":["../../../src/x402/sign.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAM1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAQ/D,OAAO,EAIL,KAAK,4BAA4B,EAElC,MAAM,cAAc,CAAC;AAqMtB;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,OAAO,EAChB,mBAAmB,EAAE,4BAA4B,EACjD,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,MAAM,CAAC,CASjB"}

package/package.json

@@ -399,7 +399,7 @@
     }
   },
   "typings": "./dist/types/exports/thirdweb.d.ts",
-  "version": "5.116.0",
+  "version": "5.116.1",
   "scripts": {
     "bench": "vitest -c ./test/vitest.config.ts bench",
     "bench:compare": "bun run ./benchmarks/run.ts",

package/src/react/core/hooks/x402/useFetchWithPaymentCore.ts

@@ -2,6 +2,7 @@
 
 import { useMutation } from "@tanstack/react-query";
 import type { ThirdwebClient } from "../../../../client/client.js";
+import type { AsyncStorage } from "../../../../utils/storage/AsyncStorage.js";
 import type { Wallet } from "../../../../wallets/interfaces/wallet.js";
 import { wrapFetchWithPayment } from "../../../../x402/fetchWithPayment.js";
 import type { RequestedPaymentRequirements } from "../../../../x402/schemas.js";
@@ -14,6 +15,11 @@ export type UseFetchWithPaymentOptions = {
     paymentRequirements: RequestedPaymentRequirements[],
   ) => RequestedPaymentRequirements | undefined;
   parseAs?: "json" | "text" | "raw";
+  /**
+   * Storage for caching permit signatures (for "upto" scheme).
+   * When provided, permit signatures will be cached and reused if the on-chain allowance is sufficient.
+   */
+  storage?: AsyncStorage;
 };
 
 type ShowErrorModalCallback = (data: {
@@ -81,7 +87,11 @@ export function useFetchWithPaymentCore(
           globalThis.fetch,
           client,
           currentWallet,
-          options,
+          {
+            maxValue: options?.maxValue,
+            paymentRequirementsSelector: options?.paymentRequirementsSelector,
+            storage: options?.storage,
+          },
         );
 
         const response = await wrappedFetch(input, init);

package/src/react/native/hooks/x402/useFetchWithPayment.ts

@@ -1,6 +1,7 @@
 "use client";
 
 import type { ThirdwebClient } from "../../../../client/client.js";
+import { nativeLocalStorage } from "../../../../utils/storage/nativeStorage.js";
 import {
   type UseFetchWithPaymentOptions,
   useFetchWithPaymentCore,
@@ -29,6 +30,7 @@ export type { UseFetchWithPaymentOptions };
  * @param options.maxValue - The maximum allowed payment amount in base units
  * @param options.paymentRequirementsSelector - Custom function to select payment requirements from available options
  * @param options.parseAs - How to parse the response: "json" (default), "text", or "raw"
+ * @param options.storage - Storage for caching permit signatures (for "upto" scheme). Provide your own AsyncStorage implementation for React Native.
  * @returns An object containing:
  * - `fetchWithPayment`: Function to make fetch requests with automatic payment handling (returns parsed data)
  * - `isPending`: Boolean indicating if a request is in progress
@@ -92,5 +94,8 @@ export function useFetchWithPayment(
   options?: UseFetchWithPaymentOptions,
 ) {
   // Native version doesn't show modal, errors bubble up naturally
-  return useFetchWithPaymentCore(client, options);
+  return useFetchWithPaymentCore(client, {
+    ...options,
+    storage: options?.storage ?? nativeLocalStorage,
+  });
 }

package/src/react/web/hooks/x402/useFetchWithPayment.tsx

@@ -1,7 +1,8 @@
 "use client";
 
-import { useContext } from "react";
+import { useContext, useMemo } from "react";
 import type { ThirdwebClient } from "../../../../client/client.js";
+import { webLocalStorage } from "../../../../utils/storage/webStorage.js";
 import type { Wallet } from "../../../../wallets/interfaces/wallet.js";
 import type { Theme } from "../../../core/design-system/index.js";
 import {
@@ -255,9 +256,18 @@ export function useFetchWithPayment(
       }
     : undefined;
 
+  // Default to webLocalStorage for permit signature caching
+  const resolvedOptions = useMemo(
+    () => ({
+      ...(options ?? {}),
+      storage: options?.storage ?? webLocalStorage,
+    }),
+    [options],
+  );
+
   return useFetchWithPaymentCore(
     client,
-    options,
+    resolvedOptions,
     showErrorModal,
     showConnectModal,
   );

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.116.0";
+export const version = "5.116.1";

package/src/x402/fetchWithPayment.ts

@@ -1,6 +1,10 @@
 import { getCachedChain } from "../chains/utils.js";
 import type { ThirdwebClient } from "../client/client.js";
+import { getAddress } from "../utils/address.js";
+import type { AsyncStorage } from "../utils/storage/AsyncStorage.js";
+import { webLocalStorage } from "../utils/storage/webStorage.js";
 import type { Wallet } from "../wallets/interfaces/wallet.js";
+import { clearPermitSignatureFromCache } from "./permitSignatureStorage.js";
 import {
   extractEvmChainId,
   networkToCaip2ChainId,
@@ -57,6 +61,11 @@ export function wrapFetchWithPayment(
     paymentRequirementsSelector?: (
       paymentRequirements: RequestedPaymentRequirements[],
     ) => RequestedPaymentRequirements | undefined;
+    /**
+     * Storage for caching permit signatures (for "upto" scheme).
+     * When provided, permit signatures will be cached and reused if the on-chain allowance is sufficient.
+     */
+    storage?: AsyncStorage;
   },
 ) {
   return async (input: RequestInfo, init?: RequestInit) => {
@@ -131,6 +140,7 @@ export function wrapFetchWithPayment(
       account,
       selectedPaymentRequirements,
       x402Version,
+      options?.storage ?? webLocalStorage,
     );
 
     const initParams = init || {};
@@ -150,6 +160,17 @@ export function wrapFetchWithPayment(
     };
 
     const secondResponse = await fetch(input, newInit);
+
+    // If payment was rejected (still 402), clear cached signature
+    if (secondResponse.status === 402 && options?.storage) {
+      await clearPermitSignatureFromCache(options.storage, {
+        chainId: paymentChainId,
+        asset: selectedPaymentRequirements.asset,
+        owner: getAddress(account.address),
+        spender: getAddress(selectedPaymentRequirements.payTo),
+      });
+    }
+
     return secondResponse;
   };
 }

package/src/x402/permitSignatureStorage.ts

@@ -0,0 +1,99 @@
+import type { AsyncStorage } from "../utils/storage/AsyncStorage.js";
+import type { RequestedPaymentPayload } from "./schemas.js";
+
+/**
+ * Cached permit signature data structure
+ */
+type CachedPermitSignature = {
+  payload: RequestedPaymentPayload;
+  deadline: string;
+  maxAmount: string;
+};
+
+/**
+ * Parameters for generating a permit cache key
+ */
+export type PermitCacheKeyParams = {
+  chainId: number;
+  asset: string;
+  owner: string;
+  spender: string;
+};
+
+const CACHE_KEY_PREFIX = "x402:permit";
+
+/**
+ * Generates a cache key for permit signature storage
+ * @param params - The parameters to generate the cache key from
+ * @returns The cache key string
+ */
+function getPermitCacheKey(params: PermitCacheKeyParams): string {
+  return `${CACHE_KEY_PREFIX}:${params.chainId}:${params.asset.toLowerCase()}:${params.owner.toLowerCase()}:${params.spender.toLowerCase()}`;
+}
+
+/**
+ * Retrieves a cached permit signature from storage
+ * @param storage - The AsyncStorage instance to use
+ * @param params - The parameters identifying the cached signature
+ * @returns The cached signature data or null if not found
+ */
+export async function getPermitSignatureFromCache(
+  storage: AsyncStorage,
+  params: PermitCacheKeyParams,
+): Promise<CachedPermitSignature | null> {
+  try {
+    const key = getPermitCacheKey(params);
+    const cached = await storage.getItem(key);
+    if (!cached) {
+      return null;
+    }
+    return JSON.parse(cached) as CachedPermitSignature;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Saves a permit signature to storage cache
+ * @param storage - The AsyncStorage instance to use
+ * @param params - The parameters identifying the signature
+ * @param payload - The signed payment payload to cache
+ * @param deadline - The deadline timestamp of the permit
+ * @param maxAmount - The maximum amount authorized
+ */
+export async function savePermitSignatureToCache(
+  storage: AsyncStorage,
+  params: PermitCacheKeyParams,
+  payload: RequestedPaymentPayload,
+  deadline: string,
+  maxAmount: string,
+): Promise<void> {
+  try {
+    const key = getPermitCacheKey(params);
+    const data: CachedPermitSignature = {
+      payload,
+      deadline,
+      maxAmount,
+    };
+    await storage.setItem(key, JSON.stringify(data));
+  } catch {
+    // Silently fail - caching is optional
+  }
+}
+
+/**
+ * Clears a cached permit signature from storage
+ * @param storage - The AsyncStorage instance to use
+ * @param params - The parameters identifying the cached signature
+ */
+export async function clearPermitSignatureFromCache(
+  storage: AsyncStorage,
+  params: PermitCacheKeyParams,
+): Promise<void> {
+  try {
+    const key = getPermitCacheKey(params);
+    await storage.removeItem(key);
+  } catch {
+    // Silently fail
+  }
+}

package/src/x402/sign.ts

@@ -3,12 +3,19 @@ import type { ExactEvmPayloadAuthorization } from "x402/types";
 import { getCachedChain } from "../chains/utils.js";
 import type { ThirdwebClient } from "../client/client.js";
 import { getContract } from "../contract/contract.js";
+import { allowance } from "../extensions/erc20/__generated__/IERC20/read/allowance.js";
 import { nonces } from "../extensions/erc20/__generated__/IERC20Permit/read/nonces.js";
 import { type Address, getAddress } from "../utils/address.js";
 import { type Hex, toHex } from "../utils/encoding/hex.js";
+import type { AsyncStorage } from "../utils/storage/AsyncStorage.js";
 import type { Account } from "../wallets/interfaces/wallet.js";
 import { getSupportedSignatureType } from "./common.js";
 import { encodePayment } from "./encode.js";
+import {
+  getPermitSignatureFromCache,
+  type PermitCacheKeyParams,
+  savePermitSignatureToCache,
+} from "./permitSignatureStorage.js";
 import {
   extractEvmChainId,
   networkToCaip2ChainId,
@@ -63,6 +70,7 @@ function preparePaymentHeader(
  * @param client - The signer wallet instance used to sign the payment header
  * @param paymentRequirements - The payment requirements containing scheme and network information
  * @param unsignedPaymentHeader - The unsigned payment payload to be signed
+ * @param storage - Optional storage for caching permit signatures (for "upto" scheme)
  * @returns A promise that resolves to the signed payment payload
  */
 async function signPaymentHeader(
@@ -70,6 +78,7 @@ async function signPaymentHeader(
   account: Account,
   paymentRequirements: RequestedPaymentRequirements,
   x402Version: number,
+  storage?: AsyncStorage,
 ): Promise<RequestedPaymentPayload> {
   const from = getAddress(account.address);
   const caip2ChainId = networkToCaip2ChainId(paymentRequirements.network);
@@ -91,6 +100,55 @@ async function signPaymentHeader(
 
   switch (supportedSignatureType) {
     case "Permit": {
+      const shouldCache =
+        paymentRequirements.scheme === "upto" && storage !== undefined;
+      const spender = getAddress(paymentRequirements.payTo);
+
+      const cacheParams: PermitCacheKeyParams = {
+        chainId,
+        asset: paymentRequirements.asset,
+        owner: from,
+        spender,
+      };
+
+      // Try to reuse cached signature for "upto" scheme
+      if (shouldCache && storage) {
+        const cached = await getPermitSignatureFromCache(storage, cacheParams);
+
+        if (cached) {
+          // Validate deadline hasn't passed
+          const now = BigInt(Math.floor(Date.now() / 1000));
+          if (BigInt(cached.deadline) > now) {
+            // Check on-chain allowance
+            const currentAllowance = await allowance({
+              contract: getContract({
+                address: paymentRequirements.asset,
+                chain: getCachedChain(chainId),
+                client,
+              }),
+              owner: from,
+              spender,
+            });
+
+            // Determine threshold - use minAmountRequired if present, else maxAmountRequired
+            const extra = paymentRequirements.extra as
+              | (ERC20TokenAmount["asset"]["eip712"] & {
+                  minAmountRequired?: string;
+                })
+              | undefined;
+            const threshold = extra?.minAmountRequired
+              ? BigInt(extra.minAmountRequired)
+              : BigInt(paymentRequirements.maxAmountRequired);
+
+            // If allowance >= threshold, reuse signature
+            if (currentAllowance >= threshold) {
+              return cached.payload;
+            }
+          }
+        }
+      }
+
+      // Generate new signature
       const nonce = await nonces({
         contract: getContract({
           address: paymentRequirements.asset,
@@ -110,13 +168,27 @@ async function signPaymentHeader(
         unsignedPaymentHeader.payload.authorization,
         paymentRequirements,
       );
-      return {
+
+      const signedPayload: RequestedPaymentPayload = {
         ...unsignedPaymentHeader,
         payload: {
           ...unsignedPaymentHeader.payload,
           signature,
         },
       };
+
+      // Cache the signature for "upto" scheme
+      if (shouldCache && storage) {
+        await savePermitSignatureToCache(
+          storage,
+          cacheParams,
+          signedPayload,
+          unsignedPaymentHeader.payload.authorization.validBefore,
+          paymentRequirements.maxAmountRequired,
+        );
+      }
+
+      return signedPayload;
     }
     case "TransferWithAuthorization": {
       // default to transfer with authorization
@@ -153,6 +225,7 @@ async function signPaymentHeader(
  * @param client - The signer wallet instance used to create the payment header
  * @param x402Version - The version of the X402 protocol to use
  * @param paymentRequirements - The payment requirements containing scheme and network information
+ * @param storage - Optional storage for caching permit signatures (for "upto" scheme)
  * @returns A promise that resolves to the encoded payment header string
  */
 export async function createPaymentHeader(
@@ -160,12 +233,14 @@ export async function createPaymentHeader(
   account: Account,
   paymentRequirements: RequestedPaymentRequirements,
   x402Version: number,
+  storage?: AsyncStorage,
 ): Promise<string> {
   const payment = await signPaymentHeader(
     client,
     account,
     paymentRequirements,
     x402Version,
+    storage,
   );
   return encodePayment(payment);
 }