thirdweb 5.108.4-nightly-2c84ac408999dbff007733f76c8f0f13818258b5-20250928000351 → 5.108.5-nightly-ce9220ea00e5a58bf3f6997733b4b69df981cba8-20250930000345

package/src/x402/common.ts

@@ -8,6 +8,7 @@ import { getContract } from "../contract/contract.js";
 import { isPermitSupported } from "../extensions/erc20/__generated__/IERC20Permit/write/permit.js";
 import { isTransferWithAuthorizationSupported } from "../extensions/erc20/__generated__/USDC/write/transferWithAuthorization.js";
 import { getAddress } from "../utils/address.js";
+import { toUnits } from "../utils/units.js";
 import { decodePayment } from "./encode.js";
 import type { ThirdwebX402Facilitator } from "./facilitator.js";
 import {
@@ -16,6 +17,7 @@ import {
   type RequestedPaymentRequirements,
 } from "./schemas.js";
 import {
+  type DefaultAsset,
   type ERC20TokenAmount,
   type PaymentArgs,
   type PaymentRequiredResult,
@@ -199,12 +201,11 @@ async function processPriceToAtomicAmount(
   chainId: number,
   facilitator: ThirdwebX402Facilitator,
 ): Promise<
-  | { maxAmountRequired: string; asset: ERC20TokenAmount["asset"] }
-  | { error: string }
+  { maxAmountRequired: string; asset: DefaultAsset } | { error: string }
 > {
   // Handle USDC amount (string) or token amount (ERC20TokenAmount)
   let maxAmountRequired: string;
-  let asset: ERC20TokenAmount["asset"];
+  let asset: DefaultAsset;
 
   if (typeof price === "string" || typeof price === "number") {
     // USDC amount in dollars
@@ -222,11 +223,32 @@ async function processPriceToAtomicAmount(
       };
     }
     asset = defaultAsset;
-    maxAmountRequired = (parsedUsdAmount * 10 ** asset.decimals).toString();
+    maxAmountRequired = toUnits(
+      parsedUsdAmount.toString(),
+      defaultAsset.decimals,
+    ).toString();
   } else {
     // Token amount in atomic units
     maxAmountRequired = price.amount;
-    asset = price.asset;
+    const tokenExtras = await getOrDetectTokenExtras({
+      facilitator,
+      partialAsset: price.asset,
+      chainId,
+    });
+    if (!tokenExtras) {
+      return {
+        error: `Unable to find token information for ${price.asset.address} on chain ${chainId}. Please specify the asset decimals and eip712 information in the asset options.`,
+      };
+    }
+    asset = {
+      address: price.asset.address,
+      decimals: tokenExtras.decimals,
+      eip712: {
+        name: tokenExtras.name,
+        version: tokenExtras.version,
+        primaryType: tokenExtras.primaryType,
+      },
+    };
   }
 
   return {
@@ -238,13 +260,12 @@ async function processPriceToAtomicAmount(
 async function getDefaultAsset(
   chainId: number,
   facilitator: ThirdwebX402Facilitator,
-): Promise<ERC20TokenAmount["asset"] | undefined> {
+): Promise<DefaultAsset | undefined> {
   const supportedAssets = await facilitator.supported();
   const matchingAsset = supportedAssets.kinds.find(
     (supported) => supported.network === `eip155:${chainId}`,
   );
-  const assetConfig = matchingAsset?.extra
-    ?.defaultAsset as ERC20TokenAmount["asset"];
+  const assetConfig = matchingAsset?.extra?.defaultAsset as DefaultAsset;
   return assetConfig;
 }
 
@@ -287,3 +308,61 @@ export async function getSupportedSignatureType(args: {
   }
   return undefined;
 }
+
+async function getOrDetectTokenExtras(args: {
+  facilitator: ThirdwebX402Facilitator;
+  partialAsset: ERC20TokenAmount["asset"];
+  chainId: number;
+}): Promise<
+  | {
+      name: string;
+      version: string;
+      decimals: number;
+      primaryType: SupportedSignatureType;
+    }
+  | undefined
+> {
+  const { facilitator, partialAsset, chainId } = args;
+  if (
+    partialAsset.eip712?.name &&
+    partialAsset.eip712?.version &&
+    partialAsset.decimals !== undefined
+  ) {
+    return {
+      name: partialAsset.eip712.name,
+      version: partialAsset.eip712.version,
+      decimals: partialAsset.decimals,
+      primaryType: partialAsset.eip712.primaryType,
+    };
+  }
+  // read from facilitator
+  const response = await facilitator
+    .supported({
+      chainId,
+      tokenAddress: partialAsset.address,
+    })
+    .catch(() => {
+      return {
+        kinds: [],
+      };
+    });
+
+  const exactScheme = response.kinds?.find((kind) => kind.scheme === "exact");
+  if (!exactScheme) {
+    return undefined;
+  }
+  const supportedAsset = exactScheme.extra?.supportedAssets?.find(
+    (asset) =>
+      asset.address.toLowerCase() === partialAsset.address.toLowerCase(),
+  );
+  if (!supportedAsset) {
+    return undefined;
+  }
+
+  return {
+    name: supportedAsset.eip712.name,
+    version: supportedAsset.eip712.version,
+    decimals: supportedAsset.decimals,
+    primaryType: supportedAsset.eip712.primaryType as SupportedSignatureType,
+  };
+}

package/src/x402/facilitator.ts

@@ -1,9 +1,10 @@
-import type { SupportedPaymentKindsResponse, VerifyResponse } from "x402/types";
+import type { VerifyResponse } from "x402/types";
 import type { ThirdwebClient } from "../client/client.js";
 import { stringify } from "../utils/json.js";
 import { withCache } from "../utils/promise/withCache.js";
 import type {
   FacilitatorSettleResponse,
+  FacilitatorSupportedResponse,
   RequestedPaymentPayload,
   RequestedPaymentRequirements,
 } from "./schemas.js";
@@ -11,6 +12,7 @@ import type {
 export type ThirdwebX402FacilitatorConfig = {
   client: ThirdwebClient;
   serverWalletAddress: string;
+  waitUtil?: "simulated" | "submitted" | "confirmed";
   vaultAccessToken?: string;
   baseUrl?: string;
 };
@@ -36,7 +38,10 @@ export type ThirdwebX402Facilitator = {
     payload: RequestedPaymentPayload,
     paymentRequirements: RequestedPaymentRequirements,
   ) => Promise<FacilitatorSettleResponse>;
-  supported: () => Promise<SupportedPaymentKindsResponse>;
+  supported: (filters?: {
+    chainId: number;
+    tokenAddress?: string;
+  }) => Promise<FacilitatorSupportedResponse>;
 };
 
 const DEFAULT_BASE_URL = "https://api.thirdweb.com/v1/payments/x402";
@@ -176,6 +181,7 @@ export function facilitator(
           x402Version: payload.x402Version,
           paymentPayload: payload,
           paymentRequirements: paymentRequirements,
+          ...(config.waitUtil ? { waitUtil: config.waitUtil } : {}),
         }),
       });
 
@@ -193,14 +199,27 @@ export function facilitator(
      *
      * @returns A promise that resolves to the supported payment kinds
      */
-    async supported(): Promise<SupportedPaymentKindsResponse> {
+    async supported(filters?: {
+      chainId: number;
+      tokenAddress?: string;
+    }): Promise<FacilitatorSupportedResponse> {
       const url = config.baseUrl ?? DEFAULT_BASE_URL;
       return withCache(
         async () => {
           let headers = { "Content-Type": "application/json" };
           const authHeaders = await facilitator.createAuthHeaders();
           headers = { ...headers, ...authHeaders.supported };
-          const res = await fetch(`${url}/supported`, { headers });
+          const supportedUrl = new URL(`${url}/supported`);
+          if (filters?.chainId) {
+            supportedUrl.searchParams.set(
+              "chainId",
+              filters.chainId.toString(),
+            );
+          }
+          if (filters?.tokenAddress) {
+            supportedUrl.searchParams.set("tokenAddress", filters.tokenAddress);
+          }
+          const res = await fetch(supportedUrl.toString(), { headers });
 
           if (res.status !== 200) {
             throw new Error(
@@ -209,11 +228,11 @@ export function facilitator(
           }
 
           const data = await res.json();
-          return data as SupportedPaymentKindsResponse;
+          return data as FacilitatorSupportedResponse;
         },
         {
-          cacheKey: `supported-payment-kinds-${url}`,
-          cacheTime: 1000 * 60 * 60 * 24, // 24 hours
+          cacheKey: `supported-payment-kinds-${url}-${filters?.chainId}-${filters?.tokenAddress}2`,
+          cacheTime: 1000 * 60 * 60 * 1, // 1 hour
         },
       );
     },

package/src/x402/fetchWithPayment.ts

@@ -61,9 +61,10 @@ export function wrapFetchWithPayment(
       return response;
     }
 
-    const { x402Version, accepts } = (await response.json()) as {
+    const { x402Version, accepts, error } = (await response.json()) as {
       x402Version: number;
       accepts: unknown[];
+      error?: string;
     };
     const parsedPaymentRequirements = accepts
       .map((x) => RequestedPaymentRequirementsSchema.parse(x))
@@ -83,6 +84,12 @@ export function wrapFetchWithPayment(
       "exact",
     );
 
+    if (!selectedPaymentRequirements) {
+      throw new Error(
+        `No suitable payment requirements found for chain ${chain.id}. ${error}`,
+      );
+    }
+
     if (BigInt(selectedPaymentRequirements.maxAmountRequired) > maxValue) {
       throw new Error(
         `Payment amount exceeds maximum allowed (currently set to ${maxValue} in base units)`,
@@ -154,9 +161,6 @@ function defaultPaymentRequirementsSelector(
     const firstPaymentRequirement = paymentRequirements.find(
       (x) => x.scheme === scheme,
     );
-    if (!firstPaymentRequirement) {
-      throw new Error("No suitable payment requirements found");
-    }
     return firstPaymentRequirement;
   }
 }

package/src/x402/schemas.ts

@@ -5,6 +5,7 @@ import {
   PaymentPayloadSchema,
   PaymentRequirementsSchema,
   SettleResponseSchema,
+  SupportedPaymentKindsResponseSchema,
 } from "x402/types";
 import { z } from "zod";
 import type { Chain } from "../chains/types.js";
@@ -56,6 +57,44 @@ export type FacilitatorSettleResponse = z.infer<
   typeof FacilitatorSettleResponseSchema
 >;
 
+export const SupportedSignatureTypeSchema = z.enum([
+  "TransferWithAuthorization",
+  "Permit",
+]);
+
+export const FacilitatorSupportedAssetSchema = z.object({
+  address: z.string(),
+  decimals: z.number(),
+  eip712: z.object({
+    name: z.string(),
+    version: z.string(),
+    primaryType: SupportedSignatureTypeSchema,
+  }),
+});
+
+const FacilitatorSupportedResponseSchema =
+  SupportedPaymentKindsResponseSchema.extend({
+    kinds: z.array(
+      z.object({
+        x402Version: z.literal(1),
+        scheme: z.literal("exact"),
+        network: FacilitatorNetworkSchema,
+        extra: z
+          .object({
+            defaultAsset: FacilitatorSupportedAssetSchema.optional(),
+            supportedAssets: z
+              .array(FacilitatorSupportedAssetSchema)
+              .optional(),
+          })
+          .optional(),
+      }),
+    ),
+  }).describe("Supported payment kinds for this facilitator");
+
+export type FacilitatorSupportedResponse = z.infer<
+  typeof FacilitatorSupportedResponseSchema
+>;
+
 export function networkToChainId(network: string | Chain): number {
   if (typeof network === "object") {
     return network.id;

package/src/x402/types.ts

@@ -1,4 +1,5 @@
 import type { Money, PaymentMiddlewareConfig } from "x402/types";
+import type z from "zod";
 import type { Chain } from "../chains/types.js";
 import type { Address } from "../utils/address.js";
 import type { Prettify } from "../utils/type-utils.js";
@@ -6,8 +7,10 @@ import type { ThirdwebX402Facilitator } from "./facilitator.js";
 import type {
   FacilitatorNetwork,
   FacilitatorSettleResponse,
+  FacilitatorSupportedAssetSchema,
   RequestedPaymentPayload,
   RequestedPaymentRequirements,
+  SupportedSignatureTypeSchema,
 } from "./schemas.js";
 
 export const x402Version = 1;
@@ -86,17 +89,21 @@ export type VerifyPaymentResult = Prettify<
   | PaymentRequiredResult
 >;
 
-export type SupportedSignatureType = "TransferWithAuthorization" | "Permit";
+export type SupportedSignatureType = z.infer<
+  typeof SupportedSignatureTypeSchema
+>;
 
 export type ERC20TokenAmount = {
   amount: string;
   asset: {
     address: `0x${string}`;
-    decimals: number;
-    eip712: {
+    decimals?: number;
+    eip712?: {
       name: string;
       version: string;
       primaryType: SupportedSignatureType;
     };
   };
 };
+
+export type DefaultAsset = z.infer<typeof FacilitatorSupportedAssetSchema>;