thirdweb 5.108.4 → 5.108.5

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,16 +1,20 @@
-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";
 
+export type WaitUntil = "simulated" | "submitted" | "confirmed";
+
 export type ThirdwebX402FacilitatorConfig = {
   client: ThirdwebClient;
   serverWalletAddress: string;
+  waitUtil?: WaitUntil;
   vaultAccessToken?: string;
   baseUrl?: string;
 };
@@ -35,8 +39,12 @@ export type ThirdwebX402Facilitator = {
   settle: (
     payload: RequestedPaymentPayload,
     paymentRequirements: RequestedPaymentRequirements,
+    waitUtil?: WaitUntil,
   ) => Promise<FacilitatorSettleResponse>;
-  supported: () => Promise<SupportedPaymentKindsResponse>;
+  supported: (filters?: {
+    chainId: number;
+    tokenAddress?: string;
+  }) => Promise<FacilitatorSupportedResponse>;
 };
 
 const DEFAULT_BASE_URL = "https://api.thirdweb.com/v1/payments/x402";
@@ -76,6 +84,21 @@ const DEFAULT_BASE_URL = "https://api.thirdweb.com/v1/payments/x402";
  *   },
  *   thirdwebX402Facilitator,
  * );
+ * ```
+ * 
+ * #### Configuration Options
+ * 
+ * ```ts
+ * const thirdwebX402Facilitator = facilitator({
+ *   client: client,
+ *   serverWalletAddress: "0x1234567890123456789012345678901234567890",
+ *   // Optional: Wait behavior for settlements
+ *   // - "simulated": Only simulate the transaction (fastest)
+ *   // - "submitted": Wait until transaction is submitted
+ *   // - "confirmed": Wait for full on-chain confirmation (slowest, default)
+ *   waitUntil: "confirmed",
+ * });
+
  * ```
  *
  * @bridge x402
@@ -162,12 +185,14 @@ export function facilitator(
     async settle(
       payload: RequestedPaymentPayload,
       paymentRequirements: RequestedPaymentRequirements,
+      waitUtil?: WaitUntil,
     ): Promise<FacilitatorSettleResponse> {
       const url = config.baseUrl ?? DEFAULT_BASE_URL;
 
       let headers = { "Content-Type": "application/json" };
       const authHeaders = await facilitator.createAuthHeaders();
       headers = { ...headers, ...authHeaders.settle };
+      const waitUtilParam = waitUtil || config.waitUtil;
 
       const res = await fetch(`${url}/settle`, {
         method: "POST",
@@ -176,6 +201,7 @@ export function facilitator(
           x402Version: payload.x402Version,
           paymentPayload: payload,
           paymentRequirements: paymentRequirements,
+          ...(waitUtilParam ? { waitUtil: waitUtilParam } : {}),
         }),
       });
 
@@ -193,14 +219,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 +248,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/settle-payment.ts

@@ -2,7 +2,7 @@ import { stringify } from "../utils/json.js";
 import { decodePaymentRequest } from "./common.js";
 import { safeBase64Encode } from "./encode.js";
 import {
-  type PaymentArgs,
+  type SettlePaymentArgs,
   type SettlePaymentResult,
   x402Version,
 } from "./types.js";
@@ -97,6 +97,7 @@ import {
  *     payTo: "0x1234567890123456789012345678901234567890",
  *     network: arbitrumSepolia, // or any other chain
  *     price: "$0.05",
+ *     waitUntil: "submitted",
  *     facilitator: thirdwebFacilitator,
  *   });
  *
@@ -124,7 +125,7 @@ import {
  * @bridge x402
  */
 export async function settlePayment(
-  args: PaymentArgs,
+  args: SettlePaymentArgs,
 ): Promise<SettlePaymentResult> {
   const { routeConfig = {}, facilitator } = args;
   const { errorMessages } = routeConfig;
@@ -142,6 +143,7 @@ export async function settlePayment(
     const settlement = await facilitator.settle(
       decodedPayment,
       selectedPaymentRequirements,
+      args.waitUntil,
     );
 
     if (settlement.success) {

package/src/x402/types.ts

@@ -1,13 +1,16 @@
 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";
-import type { ThirdwebX402Facilitator } from "./facilitator.js";
+import type { ThirdwebX402Facilitator, WaitUntil } from "./facilitator.js";
 import type {
   FacilitatorNetwork,
   FacilitatorSettleResponse,
+  FacilitatorSupportedAssetSchema,
   RequestedPaymentPayload,
   RequestedPaymentRequirements,
+  SupportedSignatureTypeSchema,
 } from "./schemas.js";
 
 export const x402Version = 1;
@@ -36,6 +39,10 @@ export type PaymentArgs = {
   routeConfig?: PaymentMiddlewareConfig;
 };
 
+export type SettlePaymentArgs = PaymentArgs & {
+  waitUntil?: WaitUntil;
+};
+
 export type PaymentRequiredResult = {
   /** HTTP 402 - Payment Required, verification or processing failed or payment missing */
   status: 402;
@@ -86,17 +93,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>;