@wtflabs/x402 0.0.1-beta.14 → 0.0.1-beta.16

package/dist/cjs/schemes/index.js

@@ -1235,483 +1235,307 @@ var usdcABI = [
   }
 ];
 
-// src/types/shared/svm/regex.ts
-var SvmAddressRegex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
-
-// src/shared/network.ts
-function getNetworkId(network) {
-  if (EvmNetworkToChainId.has(network)) {
-    return EvmNetworkToChainId.get(network);
-  }
-  if (SvmNetworkToChainId.has(network)) {
-    return SvmNetworkToChainId.get(network);
-  }
-  throw new Error(`Unsupported network: ${network}`);
-}
-
-// src/types/verify/x402Specs.ts
-var import_zod3 = require("zod");
-var EvmMaxAtomicUnits = 40;
-var EvmAddressRegex = /^0x[0-9a-fA-F]{40}$/;
-var MixedAddressRegex = /^0x[a-fA-F0-9]{40}|[A-Za-z0-9][A-Za-z0-9-]{0,34}[A-Za-z0-9]$/;
-var HexEncoded64ByteRegex = /^0x[0-9a-fA-F]{64}$/;
-var EvmSignatureRegex = /^0x[0-9a-fA-F]+$/;
-var schemes = ["exact"];
-var x402Versions = [1];
-var ErrorReasons = [
-  "insufficient_funds",
-  "invalid_exact_evm_payload_authorization_valid_after",
-  "invalid_exact_evm_payload_authorization_valid_before",
-  "invalid_exact_evm_payload_authorization_value",
-  "invalid_exact_evm_payload_signature",
-  "invalid_exact_evm_payload_recipient_mismatch",
-  "invalid_exact_svm_payload_transaction",
-  "invalid_exact_svm_payload_transaction_amount_mismatch",
-  "invalid_exact_svm_payload_transaction_create_ata_instruction",
-  "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_payee",
-  "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_asset",
-  "invalid_exact_svm_payload_transaction_instructions",
-  "invalid_exact_svm_payload_transaction_instructions_length",
-  "invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction",
-  "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction",
-  "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction_too_high",
-  "invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked",
-  "invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked",
-  "invalid_exact_svm_payload_transaction_not_a_transfer_instruction",
-  "invalid_exact_svm_payload_transaction_receiver_ata_not_found",
-  "invalid_exact_svm_payload_transaction_sender_ata_not_found",
-  "invalid_exact_svm_payload_transaction_simulation_failed",
-  "invalid_exact_svm_payload_transaction_transfer_to_incorrect_ata",
-  "invalid_network",
-  "invalid_payload",
-  "invalid_payment_requirements",
-  "invalid_scheme",
-  "invalid_payment",
-  "payment_expired",
-  "unsupported_scheme",
-  "invalid_x402_version",
-  "invalid_transaction_state",
-  "settle_exact_svm_block_height_exceeded",
-  "settle_exact_svm_transaction_confirmation_timed_out",
-  "unexpected_settle_error",
-  "unexpected_verify_error",
-  // New error reasons for Permit and Permit2
-  "unsupported_authorization_type",
-  "invalid_authorization_type",
-  "invalid_permit_signature",
-  "invalid_permit2_signature",
-  "invalid_permit2_witness_signature",
-  "witness_recipient_mismatch",
-  "permit_expired",
-  "permit2_expired",
-  "permit2_not_approved",
-  "invalid_token_address",
-  "invalid_spender_address",
-  "token_mismatch",
-  "insufficient_payment_amount",
-  "insufficient_token_balance",
-  "transaction_failed",
-  "settlement_failed"
-];
-var isInteger = (value) => Number.isInteger(Number(value)) && Number(value) >= 0;
-var hasMaxLength = (maxLength) => (value) => value.length <= maxLength;
-var EvmOrSvmAddress = import_zod3.z.string().regex(EvmAddressRegex).or(import_zod3.z.string().regex(SvmAddressRegex));
-var mixedAddressOrSvmAddress = import_zod3.z.string().regex(MixedAddressRegex).or(import_zod3.z.string().regex(SvmAddressRegex));
-var PaymentRequirementsSchema = import_zod3.z.object({
-  scheme: import_zod3.z.enum(schemes),
-  network: NetworkSchema,
-  maxAmountRequired: import_zod3.z.string().refine(isInteger),
-  resource: import_zod3.z.string().url(),
-  description: import_zod3.z.string(),
-  mimeType: import_zod3.z.string(),
-  outputSchema: import_zod3.z.record(import_zod3.z.any()).optional(),
-  payTo: EvmOrSvmAddress,
-  maxTimeoutSeconds: import_zod3.z.number().int(),
-  asset: mixedAddressOrSvmAddress,
-  paymentType: import_zod3.z.enum(["eip3009", "permit", "permit2"]).optional(),
-  extra: import_zod3.z.record(import_zod3.z.any()).optional()
-});
-var ExactEvmPayloadAuthorizationSchema = import_zod3.z.object({
-  from: import_zod3.z.string().regex(EvmAddressRegex),
-  to: import_zod3.z.string().regex(EvmAddressRegex),
-  value: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
-  validAfter: import_zod3.z.string().refine(isInteger),
-  validBefore: import_zod3.z.string().refine(isInteger),
-  nonce: import_zod3.z.string().regex(HexEncoded64ByteRegex)
-});
-var PermitEvmPayloadAuthorizationSchema = import_zod3.z.object({
-  owner: import_zod3.z.string().regex(EvmAddressRegex),
-  spender: import_zod3.z.string().regex(EvmAddressRegex),
-  value: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
-  deadline: import_zod3.z.string().refine(isInteger),
-  nonce: import_zod3.z.string().refine(isInteger)
-});
-var Permit2EvmPayloadAuthorizationSchema = import_zod3.z.object({
-  owner: import_zod3.z.string().regex(EvmAddressRegex),
-  spender: import_zod3.z.string().regex(EvmAddressRegex),
-  token: import_zod3.z.string().regex(EvmAddressRegex),
-  amount: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
-  deadline: import_zod3.z.string().refine(isInteger),
-  nonce: import_zod3.z.string().refine(isInteger),
-  to: import_zod3.z.string().regex(EvmAddressRegex).optional()
-  // Witness: binds recipient address to signature
-});
-var ExactEvmPayloadSchema = import_zod3.z.discriminatedUnion("authorizationType", [
-  import_zod3.z.object({
-    authorizationType: import_zod3.z.literal("eip3009"),
-    signature: import_zod3.z.string().regex(EvmSignatureRegex),
-    authorization: ExactEvmPayloadAuthorizationSchema
-  }),
-  import_zod3.z.object({
-    authorizationType: import_zod3.z.literal("permit"),
-    signature: import_zod3.z.string().regex(EvmSignatureRegex),
-    authorization: PermitEvmPayloadAuthorizationSchema
-  }),
-  import_zod3.z.object({
-    authorizationType: import_zod3.z.literal("permit2"),
-    signature: import_zod3.z.string().regex(EvmSignatureRegex),
-    authorization: Permit2EvmPayloadAuthorizationSchema
-  })
-]);
-var ExactSvmPayloadSchema = import_zod3.z.object({
-  transaction: import_zod3.z.string().regex(Base64EncodedRegex)
-});
-var PaymentPayloadSchema = import_zod3.z.object({
-  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
-  scheme: import_zod3.z.enum(schemes),
-  network: NetworkSchema,
-  payload: import_zod3.z.union([ExactEvmPayloadSchema, ExactSvmPayloadSchema])
-});
-var x402ResponseSchema = import_zod3.z.object({
-  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
-  error: import_zod3.z.enum(ErrorReasons).optional(),
-  accepts: import_zod3.z.array(PaymentRequirementsSchema).optional(),
-  payer: import_zod3.z.string().regex(MixedAddressRegex).optional()
-});
-var HTTPVerbsSchema = import_zod3.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]);
-var HTTPRequestStructureSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("http"),
-  method: HTTPVerbsSchema,
-  queryParams: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional(),
-  bodyType: import_zod3.z.enum(["json", "form-data", "multipart-form-data", "text", "binary"]).optional(),
-  bodyFields: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).optional(),
-  headerFields: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).optional()
-});
-var RequestStructureSchema = import_zod3.z.discriminatedUnion("type", [
-  HTTPRequestStructureSchema
-  // MCPRequestStructureSchema,
-  // OpenAPIRequestStructureSchema,
-]);
-var DiscoveredResourceSchema = import_zod3.z.object({
-  resource: import_zod3.z.string(),
-  type: import_zod3.z.enum(["http"]),
-  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
-  accepts: import_zod3.z.array(PaymentRequirementsSchema),
-  lastUpdated: import_zod3.z.date(),
-  metadata: import_zod3.z.record(import_zod3.z.any()).optional()
-});
-var SettleRequestSchema = import_zod3.z.object({
-  paymentPayload: PaymentPayloadSchema,
-  paymentRequirements: PaymentRequirementsSchema
-});
-var VerifyRequestSchema = import_zod3.z.object({
-  paymentPayload: PaymentPayloadSchema,
-  paymentRequirements: PaymentRequirementsSchema
-});
-var VerifyResponseSchema = import_zod3.z.object({
-  isValid: import_zod3.z.boolean(),
-  invalidReason: import_zod3.z.enum(ErrorReasons).optional(),
-  payer: EvmOrSvmAddress.optional()
-});
-var SettleResponseSchema = import_zod3.z.object({
-  success: import_zod3.z.boolean(),
-  errorReason: import_zod3.z.enum(ErrorReasons).optional(),
-  payer: EvmOrSvmAddress.optional(),
-  transaction: import_zod3.z.string().regex(MixedAddressRegex),
-  network: NetworkSchema
-});
-var ListDiscoveryResourcesRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.string().optional(),
-  limit: import_zod3.z.number().optional(),
-  offset: import_zod3.z.number().optional()
-});
-var ListDiscoveryResourcesResponseSchema = import_zod3.z.object({
-  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
-  items: import_zod3.z.array(DiscoveredResourceSchema),
-  pagination: import_zod3.z.object({
-    limit: import_zod3.z.number(),
-    offset: import_zod3.z.number(),
-    total: import_zod3.z.number()
-  })
-});
-var SupportedPaymentKindSchema = import_zod3.z.object({
-  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
-  scheme: import_zod3.z.enum(schemes),
-  network: NetworkSchema,
-  extra: import_zod3.z.record(import_zod3.z.any()).optional()
-});
-var SupportedPaymentKindsResponseSchema = import_zod3.z.object({
-  kinds: import_zod3.z.array(SupportedPaymentKindSchema)
-});
-
-// src/types/verify/facilitator.ts
-var import_zod4 = require("zod");
-var facilitatorRequestSchema = import_zod4.z.object({
-  paymentHeader: import_zod4.z.string(),
-  paymentRequirements: PaymentRequirementsSchema
-});
-
-// src/shared/evm/usdc.ts
-function getUsdcAddress(client) {
-  return config[client.chain.id.toString()].usdcAddress;
-}
-var versionCache = /* @__PURE__ */ new Map();
-async function getVersion(client, tokenAddress) {
-  const address = tokenAddress ?? getUsdcAddress(client);
-  const cacheKey = `${client.chain.id}-${address.toLowerCase()}`;
-  if (versionCache.has(cacheKey)) {
-    return versionCache.get(cacheKey);
-  }
-  let version = "1";
-  try {
-    const eip712DomainABI = [
-      {
-        inputs: [],
-        name: "eip712Domain",
-        outputs: [
-          { name: "fields", type: "bytes1" },
-          { name: "name", type: "string" },
-          { name: "version", type: "string" },
-          { name: "chainId", type: "uint256" },
-          { name: "verifyingContract", type: "address" },
-          { name: "salt", type: "bytes32" },
-          { name: "extensions", type: "uint256[]" }
-        ],
-        stateMutability: "view",
-        type: "function"
-      }
-    ];
-    const result = await client.readContract({
-      address,
-      abi: eip712DomainABI,
-      functionName: "eip712Domain"
-    });
-    version = result[2];
-  } catch {
-    try {
-      const result = await client.readContract({
-        address,
-        abi: usdcABI,
-        functionName: "version"
-      });
-      version = result;
-    } catch {
-      console.warn(
-        `Neither eip712Domain() nor version() available for token ${address}, using default: ${version}`
-      );
-    }
-  }
-  versionCache.set(cacheKey, version);
-  return version;
-}
-
-// src/shared/evm/erc20.ts
-async function getERC20Balance(client, erc20Address, address) {
-  const balance = await client.readContract({
-    address: erc20Address,
-    abi: usdcABI,
-    functionName: "balanceOf",
-    args: [address]
-  });
-  return balance;
-}
-async function getERC20Allowance(client, erc20Address, owner, spender) {
-  const allowance = await client.readContract({
-    address: erc20Address,
-    abi: usdcABI,
-    functionName: "allowance",
-    args: [owner, spender]
-  });
-  return allowance;
-}
-
-// src/shared/svm/transaction.ts
-var import_kit3 = require("@solana/kit");
-var import_token = require("@solana-program/token");
-var import_token_2022 = require("@solana-program/token-2022");
-function decodeTransactionFromPayload(svmPayload) {
-  try {
-    const base64Encoder = (0, import_kit3.getBase64Encoder)();
-    const transactionBytes = base64Encoder.encode(svmPayload.transaction);
-    const transactionDecoder = (0, import_kit3.getTransactionDecoder)();
-    return transactionDecoder.decode(transactionBytes);
-  } catch (error) {
-    console.error("error", error);
-    throw new Error("invalid_exact_svm_payload_transaction");
-  }
-}
-function getTokenPayerFromTransaction(transaction) {
-  const compiled = (0, import_kit3.getCompiledTransactionMessageDecoder)().decode(
-    transaction.messageBytes
-  );
-  const staticAccounts = compiled.staticAccounts ?? [];
-  const instructions = compiled.instructions ?? [];
-  for (const ix of instructions) {
-    const programIndex = ix.programAddressIndex;
-    const programAddress = staticAccounts[programIndex].toString();
-    if (programAddress === import_token.TOKEN_PROGRAM_ADDRESS.toString() || programAddress === import_token_2022.TOKEN_2022_PROGRAM_ADDRESS.toString()) {
-      const accountIndices = ix.accountIndices ?? [];
-      if (accountIndices.length >= 4) {
-        const ownerIndex = accountIndices[3];
-        const ownerAddress = staticAccounts[ownerIndex].toString();
-        if (ownerAddress) return ownerAddress;
+// src/types/shared/evm/eip7702ABI.ts
+var EIP7702SellerWalletMinimalAbi = [
+  {
+    inputs: [],
+    name: "InvalidAmount",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "NotOwner",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ReentrancyGuardReentrantCall",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
       }
-    }
-  }
-  return "";
-}
-async function signAndSimulateTransaction(signer, transaction, rpc) {
-  const signedTransaction = await (0, import_kit3.partiallySignTransaction)([signer.keyPair], transaction);
-  const base64EncodedTransaction = (0, import_kit3.getBase64EncodedWireTransaction)(signedTransaction);
-  const simulateTxConfig = {
-    sigVerify: true,
-    replaceRecentBlockhash: false,
-    commitment: "confirmed",
-    encoding: "base64",
-    accounts: void 0,
-    innerInstructions: void 0,
-    minContextSlot: void 0
-  };
-  const simulateResult = await rpc.simulateTransaction(base64EncodedTransaction, simulateTxConfig).send();
-  return simulateResult;
-}
-
-// src/types/shared/evm/permitProxyABI.ts
-var permitProxyContractABI = [
-  // settleWithPermit - 使用 EIP-2612 Permit 进行结算
+    ],
+    name: "SafeERC20FailedOperation",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ZeroAddress",
+    type: "error"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "beneficiary",
+        type: "address"
+      }
+    ],
+    name: "ConfigUpdated",
+    type: "event"
+  },
   {
+    anonymous: false,
     inputs: [
       {
+        indexed: true,
         internalType: "address",
         name: "token",
         type: "address"
       },
       {
+        indexed: true,
         internalType: "address",
         name: "payer",
         type: "address"
       },
       {
+        indexed: true,
         internalType: "address",
-        name: "seller",
+        name: "facilitator",
         type: "address"
       },
       {
+        indexed: false,
         internalType: "uint256",
         name: "amount",
         type: "uint256"
       },
       {
+        indexed: false,
         internalType: "uint256",
-        name: "deadline",
+        name: "beneficiaryAmount",
         type: "uint256"
       },
       {
-        internalType: "uint8",
-        name: "v",
-        type: "uint8"
+        indexed: false,
+        internalType: "uint256",
+        name: "feeAmount",
+        type: "uint256"
       },
       {
-        internalType: "bytes32",
-        name: "r",
-        type: "bytes32"
+        indexed: false,
+        internalType: "string",
+        name: "method",
+        type: "string"
+      }
+    ],
+    name: "SettlementExecuted",
+    type: "event"
+  },
+  {
+    stateMutability: "payable",
+    type: "fallback"
+  },
+  {
+    inputs: [],
+    name: "BASIS_POINTS",
+    outputs: [
+      {
+        internalType: "uint96",
+        name: "",
+        type: "uint96"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "FEE_BPS",
+    outputs: [
+      {
+        internalType: "uint96",
+        name: "",
+        type: "uint96"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "FEE_RECIPIENT",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getConfig",
+    outputs: [
+      {
+        internalType: "address",
+        name: "beneficiary",
+        type: "address"
       },
       {
-        internalType: "bytes32",
-        name: "s",
-        type: "bytes32"
+        internalType: "bool",
+        name: "initialized",
+        type: "bool"
       }
     ],
-    name: "settleWithPermit",
-    outputs: [],
-    stateMutability: "nonpayable",
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getEffectiveConfig",
+    outputs: [
+      {
+        internalType: "address",
+        name: "beneficiary",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "feeRecipient",
+        type: "address"
+      },
+      {
+        internalType: "uint96",
+        name: "feeBps",
+        type: "uint96"
+      }
+    ],
+    stateMutability: "view",
     type: "function"
   },
-  // settleWithERC3009 - 使用 EIP-3009 TransferWithAuthorization 进行结算
   {
     inputs: [
       {
         internalType: "address",
-        name: "token",
+        name: "",
         type: "address"
       },
       {
         internalType: "address",
-        name: "payer",
+        name: "",
         type: "address"
       },
+      {
+        internalType: "uint256[]",
+        name: "",
+        type: "uint256[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    name: "onERC1155BatchReceived",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
       {
         internalType: "address",
-        name: "seller",
+        name: "",
         type: "address"
       },
       {
-        internalType: "uint256",
-        name: "amount",
-        type: "uint256"
+        internalType: "address",
+        name: "",
+        type: "address"
       },
       {
         internalType: "uint256",
-        name: "validAfter",
+        name: "",
         type: "uint256"
       },
       {
         internalType: "uint256",
-        name: "validBefore",
+        name: "",
         type: "uint256"
       },
       {
-        internalType: "bytes32",
-        name: "nonce",
-        type: "bytes32"
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    name: "onERC1155Received",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
       },
       {
-        internalType: "uint8",
-        name: "v",
-        type: "uint8"
+        internalType: "address",
+        name: "",
+        type: "address"
       },
       {
-        internalType: "bytes32",
-        name: "r",
-        type: "bytes32"
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
       },
       {
-        internalType: "bytes32",
-        name: "s",
-        type: "bytes32"
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    name: "onERC721Received",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
       }
     ],
-    name: "settleWithERC3009",
-    outputs: [],
     stateMutability: "nonpayable",
     type: "function"
   },
-  // settleWithERC3009Direct - 直接结算（无手续费）
   {
     inputs: [
       {
         internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "payer",
+        name: "token",
         type: "address"
       },
       {
         internalType: "address",
-        name: "seller",
+        name: "payer",
         type: "address"
       },
       {
@@ -1750,99 +1574,442 @@ var permitProxyContractABI = [
         type: "bytes32"
       }
     ],
-    name: "settleWithERC3009Direct",
+    name: "settleWithERC3009",
     outputs: [],
     stateMutability: "nonpayable",
     type: "function"
   },
-  // Events
   {
-    anonymous: false,
     inputs: [
       {
-        indexed: true,
         internalType: "address",
         name: "token",
         type: "address"
       },
       {
-        indexed: true,
         internalType: "address",
         name: "payer",
         type: "address"
       },
       {
-        indexed: true,
-        internalType: "address",
-        name: "seller",
-        type: "address"
-      },
-      {
-        indexed: false,
         internalType: "uint256",
         name: "amount",
         type: "uint256"
       },
       {
-        indexed: false,
         internalType: "uint256",
-        name: "sellerAmount",
+        name: "deadline",
         type: "uint256"
       },
       {
-        indexed: false,
-        internalType: "uint256",
-        name: "feeAmount",
-        type: "uint256"
+        internalType: "uint8",
+        name: "v",
+        type: "uint8"
+      },
+      {
+        internalType: "bytes32",
+        name: "r",
+        type: "bytes32"
       },
       {
-        indexed: false,
-        internalType: "string",
-        name: "path",
-        type: "string"
+        internalType: "bytes32",
+        name: "s",
+        type: "bytes32"
+      }
+    ],
+    name: "settleWithPermit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceId",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "beneficiary_",
+        type: "address"
+      }
+    ],
+    name: "updateConfig",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    stateMutability: "payable",
+    type: "receive"
+  }
+];
+
+// src/types/shared/svm/regex.ts
+var SvmAddressRegex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+
+// src/shared/network.ts
+function getNetworkId(network) {
+  if (EvmNetworkToChainId.has(network)) {
+    return EvmNetworkToChainId.get(network);
+  }
+  if (SvmNetworkToChainId.has(network)) {
+    return SvmNetworkToChainId.get(network);
+  }
+  throw new Error(`Unsupported network: ${network}`);
+}
+
+// src/types/verify/x402Specs.ts
+var import_zod3 = require("zod");
+var EvmMaxAtomicUnits = 40;
+var EvmAddressRegex = /^0x[0-9a-fA-F]{40}$/;
+var MixedAddressRegex = /^0x[a-fA-F0-9]{40}|[A-Za-z0-9][A-Za-z0-9-]{0,34}[A-Za-z0-9]$/;
+var HexEncoded64ByteRegex = /^0x[0-9a-fA-F]{64}$/;
+var EvmSignatureRegex = /^0x[0-9a-fA-F]+$/;
+var schemes = ["exact"];
+var x402Versions = [1];
+var ErrorReasons = [
+  "insufficient_funds",
+  "invalid_exact_evm_payload_authorization_valid_after",
+  "invalid_exact_evm_payload_authorization_valid_before",
+  "invalid_exact_evm_payload_authorization_value",
+  "invalid_exact_evm_payload_signature",
+  "invalid_exact_evm_payload_recipient_mismatch",
+  "invalid_exact_svm_payload_transaction",
+  "invalid_exact_svm_payload_transaction_amount_mismatch",
+  "invalid_exact_svm_payload_transaction_create_ata_instruction",
+  "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_payee",
+  "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_asset",
+  "invalid_exact_svm_payload_transaction_instructions",
+  "invalid_exact_svm_payload_transaction_instructions_length",
+  "invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction",
+  "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction",
+  "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction_too_high",
+  "invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked",
+  "invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked",
+  "invalid_exact_svm_payload_transaction_not_a_transfer_instruction",
+  "invalid_exact_svm_payload_transaction_receiver_ata_not_found",
+  "invalid_exact_svm_payload_transaction_sender_ata_not_found",
+  "invalid_exact_svm_payload_transaction_simulation_failed",
+  "invalid_exact_svm_payload_transaction_transfer_to_incorrect_ata",
+  "invalid_network",
+  "invalid_payload",
+  "invalid_payment_requirements",
+  "invalid_scheme",
+  "invalid_payment",
+  "payment_expired",
+  "unsupported_scheme",
+  "invalid_x402_version",
+  "invalid_transaction_state",
+  "settle_exact_svm_block_height_exceeded",
+  "settle_exact_svm_transaction_confirmation_timed_out",
+  "unexpected_settle_error",
+  "unexpected_verify_error",
+  // New error reasons for Permit and Permit2
+  "unsupported_authorization_type",
+  "invalid_authorization_type",
+  "invalid_permit_signature",
+  "invalid_permit2_signature",
+  "invalid_permit2_witness_signature",
+  "witness_recipient_mismatch",
+  "permit_expired",
+  "permit2_expired",
+  "permit2_not_approved",
+  "invalid_token_address",
+  "invalid_spender_address",
+  "token_mismatch",
+  "insufficient_payment_amount",
+  "insufficient_token_balance",
+  "transaction_failed",
+  "settlement_failed"
+];
+var isInteger = (value) => Number.isInteger(Number(value)) && Number(value) >= 0;
+var hasMaxLength = (maxLength) => (value) => value.length <= maxLength;
+var EvmOrSvmAddress = import_zod3.z.string().regex(EvmAddressRegex).or(import_zod3.z.string().regex(SvmAddressRegex));
+var mixedAddressOrSvmAddress = import_zod3.z.string().regex(MixedAddressRegex).or(import_zod3.z.string().regex(SvmAddressRegex));
+var PaymentRequirementsSchema = import_zod3.z.object({
+  scheme: import_zod3.z.enum(schemes),
+  network: NetworkSchema,
+  maxAmountRequired: import_zod3.z.string().refine(isInteger),
+  resource: import_zod3.z.string().url(),
+  description: import_zod3.z.string(),
+  mimeType: import_zod3.z.string(),
+  outputSchema: import_zod3.z.record(import_zod3.z.any()).optional(),
+  payTo: EvmOrSvmAddress,
+  maxTimeoutSeconds: import_zod3.z.number().int(),
+  asset: mixedAddressOrSvmAddress,
+  paymentType: import_zod3.z.enum(["eip3009", "permit", "permit2"]).optional(),
+  extra: import_zod3.z.record(import_zod3.z.any()).optional()
+});
+var ExactEvmPayloadAuthorizationSchema = import_zod3.z.object({
+  from: import_zod3.z.string().regex(EvmAddressRegex),
+  to: import_zod3.z.string().regex(EvmAddressRegex),
+  value: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
+  validAfter: import_zod3.z.string().refine(isInteger),
+  validBefore: import_zod3.z.string().refine(isInteger),
+  nonce: import_zod3.z.string().regex(HexEncoded64ByteRegex)
+});
+var PermitEvmPayloadAuthorizationSchema = import_zod3.z.object({
+  owner: import_zod3.z.string().regex(EvmAddressRegex),
+  spender: import_zod3.z.string().regex(EvmAddressRegex),
+  value: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
+  deadline: import_zod3.z.string().refine(isInteger),
+  nonce: import_zod3.z.string().refine(isInteger)
+});
+var Permit2EvmPayloadAuthorizationSchema = import_zod3.z.object({
+  owner: import_zod3.z.string().regex(EvmAddressRegex),
+  spender: import_zod3.z.string().regex(EvmAddressRegex),
+  token: import_zod3.z.string().regex(EvmAddressRegex),
+  amount: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
+  deadline: import_zod3.z.string().refine(isInteger),
+  nonce: import_zod3.z.string().refine(isInteger),
+  to: import_zod3.z.string().regex(EvmAddressRegex).optional()
+  // Witness: binds recipient address to signature
+});
+var ExactEvmPayloadSchema = import_zod3.z.discriminatedUnion("authorizationType", [
+  import_zod3.z.object({
+    authorizationType: import_zod3.z.literal("eip3009"),
+    signature: import_zod3.z.string().regex(EvmSignatureRegex),
+    authorization: ExactEvmPayloadAuthorizationSchema
+  }),
+  import_zod3.z.object({
+    authorizationType: import_zod3.z.literal("permit"),
+    signature: import_zod3.z.string().regex(EvmSignatureRegex),
+    authorization: PermitEvmPayloadAuthorizationSchema
+  }),
+  import_zod3.z.object({
+    authorizationType: import_zod3.z.literal("permit2"),
+    signature: import_zod3.z.string().regex(EvmSignatureRegex),
+    authorization: Permit2EvmPayloadAuthorizationSchema
+  })
+]);
+var ExactSvmPayloadSchema = import_zod3.z.object({
+  transaction: import_zod3.z.string().regex(Base64EncodedRegex)
+});
+var PaymentPayloadSchema = import_zod3.z.object({
+  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
+  scheme: import_zod3.z.enum(schemes),
+  network: NetworkSchema,
+  payload: import_zod3.z.union([ExactEvmPayloadSchema, ExactSvmPayloadSchema])
+});
+var x402ResponseSchema = import_zod3.z.object({
+  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
+  error: import_zod3.z.enum(ErrorReasons).optional(),
+  accepts: import_zod3.z.array(PaymentRequirementsSchema).optional(),
+  payer: import_zod3.z.string().regex(MixedAddressRegex).optional()
+});
+var HTTPVerbsSchema = import_zod3.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]);
+var HTTPRequestStructureSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("http"),
+  method: HTTPVerbsSchema,
+  queryParams: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional(),
+  bodyType: import_zod3.z.enum(["json", "form-data", "multipart-form-data", "text", "binary"]).optional(),
+  bodyFields: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).optional(),
+  headerFields: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).optional()
+});
+var RequestStructureSchema = import_zod3.z.discriminatedUnion("type", [
+  HTTPRequestStructureSchema
+  // MCPRequestStructureSchema,
+  // OpenAPIRequestStructureSchema,
+]);
+var DiscoveredResourceSchema = import_zod3.z.object({
+  resource: import_zod3.z.string(),
+  type: import_zod3.z.enum(["http"]),
+  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
+  accepts: import_zod3.z.array(PaymentRequirementsSchema),
+  lastUpdated: import_zod3.z.date(),
+  metadata: import_zod3.z.record(import_zod3.z.any()).optional()
+});
+var SettleRequestSchema = import_zod3.z.object({
+  paymentPayload: PaymentPayloadSchema,
+  paymentRequirements: PaymentRequirementsSchema
+});
+var VerifyRequestSchema = import_zod3.z.object({
+  paymentPayload: PaymentPayloadSchema,
+  paymentRequirements: PaymentRequirementsSchema
+});
+var VerifyResponseSchema = import_zod3.z.object({
+  isValid: import_zod3.z.boolean(),
+  invalidReason: import_zod3.z.enum(ErrorReasons).optional(),
+  payer: EvmOrSvmAddress.optional()
+});
+var SettleResponseSchema = import_zod3.z.object({
+  success: import_zod3.z.boolean(),
+  errorReason: import_zod3.z.enum(ErrorReasons).optional(),
+  payer: EvmOrSvmAddress.optional(),
+  transaction: import_zod3.z.string().regex(MixedAddressRegex),
+  network: NetworkSchema
+});
+var ListDiscoveryResourcesRequestSchema = import_zod3.z.object({
+  type: import_zod3.z.string().optional(),
+  limit: import_zod3.z.number().optional(),
+  offset: import_zod3.z.number().optional()
+});
+var ListDiscoveryResourcesResponseSchema = import_zod3.z.object({
+  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
+  items: import_zod3.z.array(DiscoveredResourceSchema),
+  pagination: import_zod3.z.object({
+    limit: import_zod3.z.number(),
+    offset: import_zod3.z.number(),
+    total: import_zod3.z.number()
+  })
+});
+var SupportedPaymentKindSchema = import_zod3.z.object({
+  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
+  scheme: import_zod3.z.enum(schemes),
+  network: NetworkSchema,
+  extra: import_zod3.z.record(import_zod3.z.any()).optional()
+});
+var SupportedPaymentKindsResponseSchema = import_zod3.z.object({
+  kinds: import_zod3.z.array(SupportedPaymentKindSchema)
+});
+
+// src/types/verify/facilitator.ts
+var import_zod4 = require("zod");
+var facilitatorRequestSchema = import_zod4.z.object({
+  paymentHeader: import_zod4.z.string(),
+  paymentRequirements: PaymentRequirementsSchema
+});
+
+// src/shared/evm/usdc.ts
+function getUsdcAddress(client) {
+  return config[client.chain.id.toString()].usdcAddress;
+}
+var versionCache = /* @__PURE__ */ new Map();
+async function getVersion(client, tokenAddress) {
+  const address = tokenAddress ?? getUsdcAddress(client);
+  const cacheKey = `${client.chain.id}-${address.toLowerCase()}`;
+  if (versionCache.has(cacheKey)) {
+    return versionCache.get(cacheKey);
+  }
+  let version = "1";
+  try {
+    const eip712DomainABI = [
+      {
+        inputs: [],
+        name: "eip712Domain",
+        outputs: [
+          { name: "fields", type: "bytes1" },
+          { name: "name", type: "string" },
+          { name: "version", type: "string" },
+          { name: "chainId", type: "uint256" },
+          { name: "verifyingContract", type: "address" },
+          { name: "salt", type: "bytes32" },
+          { name: "extensions", type: "uint256[]" }
+        ],
+        stateMutability: "view",
+        type: "function"
       }
-    ],
-    name: "SettledSplit",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "payer",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "seller",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "amount",
-        type: "uint256"
-      },
-      {
-        indexed: false,
-        internalType: "string",
-        name: "path",
-        type: "string"
+    ];
+    const result = await client.readContract({
+      address,
+      abi: eip712DomainABI,
+      functionName: "eip712Domain"
+    });
+    version = result[2];
+  } catch {
+    try {
+      const result = await client.readContract({
+        address,
+        abi: usdcABI,
+        functionName: "version"
+      });
+      version = result;
+    } catch {
+      console.warn(
+        `Neither eip712Domain() nor version() available for token ${address}, using default: ${version}`
+      );
+    }
+  }
+  versionCache.set(cacheKey, version);
+  return version;
+}
+
+// src/shared/evm/erc20.ts
+async function getERC20Balance(client, erc20Address, address) {
+  const balance = await client.readContract({
+    address: erc20Address,
+    abi: usdcABI,
+    functionName: "balanceOf",
+    args: [address]
+  });
+  return balance;
+}
+async function getERC20Allowance(client, erc20Address, owner, spender) {
+  const allowance = await client.readContract({
+    address: erc20Address,
+    abi: usdcABI,
+    functionName: "allowance",
+    args: [owner, spender]
+  });
+  return allowance;
+}
+
+// src/shared/svm/transaction.ts
+var import_kit3 = require("@solana/kit");
+var import_token = require("@solana-program/token");
+var import_token_2022 = require("@solana-program/token-2022");
+function decodeTransactionFromPayload(svmPayload) {
+  try {
+    const base64Encoder = (0, import_kit3.getBase64Encoder)();
+    const transactionBytes = base64Encoder.encode(svmPayload.transaction);
+    const transactionDecoder = (0, import_kit3.getTransactionDecoder)();
+    return transactionDecoder.decode(transactionBytes);
+  } catch (error) {
+    console.error("error", error);
+    throw new Error("invalid_exact_svm_payload_transaction");
+  }
+}
+function getTokenPayerFromTransaction(transaction) {
+  const compiled = (0, import_kit3.getCompiledTransactionMessageDecoder)().decode(
+    transaction.messageBytes
+  );
+  const staticAccounts = compiled.staticAccounts ?? [];
+  const instructions = compiled.instructions ?? [];
+  for (const ix of instructions) {
+    const programIndex = ix.programAddressIndex;
+    const programAddress = staticAccounts[programIndex].toString();
+    if (programAddress === import_token.TOKEN_PROGRAM_ADDRESS.toString() || programAddress === import_token_2022.TOKEN_2022_PROGRAM_ADDRESS.toString()) {
+      const accountIndices = ix.accountIndices ?? [];
+      if (accountIndices.length >= 4) {
+        const ownerIndex = accountIndices[3];
+        const ownerAddress = staticAccounts[ownerIndex].toString();
+        if (ownerAddress) return ownerAddress;
       }
-    ],
-    name: "SettledDirect",
-    type: "event"
+    }
   }
-];
+  return "";
+}
+async function signAndSimulateTransaction(signer, transaction, rpc) {
+  const signedTransaction = await (0, import_kit3.partiallySignTransaction)([signer.keyPair], transaction);
+  const base64EncodedTransaction = (0, import_kit3.getBase64EncodedWireTransaction)(signedTransaction);
+  const simulateTxConfig = {
+    sigVerify: true,
+    replaceRecentBlockhash: false,
+    commitment: "confirmed",
+    encoding: "base64",
+    accounts: void 0,
+    innerInstructions: void 0,
+    minContextSlot: void 0
+  };
+  const simulateResult = await rpc.simulateTransaction(base64EncodedTransaction, simulateTxConfig).send();
+  return simulateResult;
+}
 
 // src/schemes/exact/evm/eip3009/facilitator.ts
 async function verify(client, payload, paymentRequirements) {
@@ -1908,7 +2075,7 @@ async function verify(client, payload, paymentRequirements) {
       payer: exactEvmPayload.authorization.from
     };
   }
-  if ((0, import_viem2.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem2.getAddress)(paymentRequirements.payTo) && (0, import_viem2.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem2.getAddress)(paymentRequirements.extra?.relayer)) {
+  if ((0, import_viem2.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem2.getAddress)(paymentRequirements.payTo)) {
     return {
       isValid: false,
       invalidReason: "invalid_exact_evm_payload_recipient_mismatch",
@@ -1981,57 +2148,36 @@ async function settle(wallet, paymentPayload, paymentRequirements) {
     };
   }
   const { signature } = (0, import_viem2.parseErc6492Signature)(payload.signature);
-  let tx;
-  if (paymentRequirements.extra?.relayer) {
-    const sig = (0, import_viem2.hexToSignature)(signature);
-    const v = Number(sig.v);
-    const r = sig.r;
-    const s = sig.s;
-    tx = await wallet.writeContract({
-      address: paymentRequirements.extra.relayer,
-      abi: permitProxyContractABI,
-      functionName: "settleWithERC3009",
-      args: [
-        paymentRequirements.asset,
-        // token
-        payload.authorization.from,
-        // payer
-        paymentRequirements.payTo,
-        // seller
-        BigInt(payload.authorization.value),
-        // amount
-        BigInt(payload.authorization.validAfter),
-        // validAfter
-        BigInt(payload.authorization.validBefore),
-        // validBefore
-        payload.authorization.nonce,
-        // nonce
-        v,
-        // v (uint8)
-        r,
-        // r (bytes32)
-        s
-        // s (bytes32)
-      ],
-      chain: wallet.chain
-    });
-  } else {
-    tx = await wallet.writeContract({
-      address: paymentRequirements.asset,
-      abi: usdcABI,
-      functionName: "transferWithAuthorization",
-      args: [
-        payload.authorization.from,
-        payload.authorization.to,
-        BigInt(payload.authorization.value),
-        BigInt(payload.authorization.validAfter),
-        BigInt(payload.authorization.validBefore),
-        payload.authorization.nonce,
-        signature
-      ],
-      chain: wallet.chain
-    });
-  }
+  const sig = (0, import_viem2.hexToSignature)(signature);
+  const v = Number(sig.v);
+  const r = sig.r;
+  const s = sig.s;
+  const tx = await wallet.writeContract({
+    address: paymentRequirements.payTo,
+    abi: EIP7702SellerWalletMinimalAbi,
+    functionName: "settleWithERC3009",
+    args: [
+      paymentRequirements.asset,
+      // token
+      payload.authorization.from,
+      // payer
+      BigInt(payload.authorization.value),
+      // amount
+      BigInt(payload.authorization.validAfter),
+      // validAfter
+      BigInt(payload.authorization.validBefore),
+      // validBefore
+      payload.authorization.nonce,
+      // nonce
+      v,
+      // v (uint8)
+      r,
+      // r (bytes32)
+      s
+      // s (bytes32)
+    ],
+    chain: wallet.chain
+  });
   const receipt = await wallet.waitForTransactionReceipt({ hash: tx });
   if (receipt.status !== "success") {
     return {
@@ -2192,22 +2338,12 @@ async function verify2(client, payload, paymentRequirements) {
       payer: owner
     };
   }
-  if (paymentRequirements.extra?.relayer) {
-    if ((0, import_viem4.getAddress)(spender) !== (0, import_viem4.getAddress)(paymentRequirements.extra?.relayer)) {
-      return {
-        isValid: false,
-        invalidReason: "invalid_spender_address",
-        payer: owner
-      };
-    }
-  } else {
-    if (client.account && (0, import_viem4.getAddress)(spender) !== (0, import_viem4.getAddress)(client.account.address)) {
-      return {
-        isValid: false,
-        invalidReason: "invalid_spender_address",
-        payer: owner
-      };
-    }
+  if ((0, import_viem4.getAddress)(spender) !== (0, import_viem4.getAddress)(paymentRequirements.payTo)) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_spender_address",
+      payer: owner
+    };
   }
   const balance = await getERC20Balance(client, erc20Address, owner);
   if (balance < BigInt(paymentRequirements.maxAmountRequired)) {
@@ -2250,84 +2386,40 @@ async function settle2(wallet, paymentPayload, paymentRequirements) {
       payer: permitPayload.authorization.owner
     };
   }
-  const { owner, spender, value, deadline } = permitPayload.authorization;
+  const { owner, value, deadline } = permitPayload.authorization;
   const { v, r, s } = splitSignature(permitPayload.signature);
   const tokenAddress = paymentRequirements.asset;
-  const txNonce = await wallet.getTransactionCount({
-    address: wallet.account.address
+  const transactionHash = await wallet.writeContract({
+    address: paymentRequirements.payTo,
+    abi: EIP7702SellerWalletMinimalAbi,
+    functionName: "settleWithPermit",
+    args: [
+      tokenAddress,
+      // token
+      owner,
+      // payer
+      BigInt(value),
+      // amount
+      BigInt(deadline),
+      // deadline
+      v,
+      // v
+      r,
+      // r
+      s
+      // s
+    ],
+    chain: wallet.chain
   });
-  let transactionHash;
-  if (paymentRequirements.extra?.relayer) {
-    transactionHash = await wallet.writeContract({
-      address: paymentRequirements.extra.relayer,
-      abi: permitProxyContractABI,
-      functionName: "settleWithPermit",
-      args: [
-        tokenAddress,
-        // token
-        owner,
-        // payer
-        paymentRequirements.payTo,
-        // seller
-        BigInt(value),
-        // amount
-        BigInt(deadline),
-        // deadline
-        v,
-        // v
-        r,
-        // r
-        s
-        // s
-      ],
-      chain: wallet.chain,
-      nonce: txNonce
-    });
-    const receipt = await wallet.waitForTransactionReceipt({ hash: transactionHash });
-    if (receipt.status !== "success") {
-      return {
-        success: false,
-        errorReason: "transaction_failed",
-        transaction: transactionHash,
-        network: paymentPayload.network,
-        payer: owner
-      };
-    }
-  } else {
-    const [permitTx, transferTx] = await Promise.all([
-      // Call permit to approve the spender
-      wallet.writeContract({
-        address: tokenAddress,
-        abi: erc20PermitABI,
-        functionName: "permit",
-        args: [owner, spender, BigInt(value), BigInt(deadline), v, r, s],
-        chain: wallet.chain,
-        nonce: txNonce
-      }),
-      // Call transferFrom to transfer tokens to payTo address
-      wallet.writeContract({
-        address: tokenAddress,
-        abi: erc20PermitABI,
-        functionName: "transferFrom",
-        args: [owner, paymentRequirements.payTo, BigInt(value)],
-        chain: wallet.chain,
-        nonce: txNonce + 1
-      })
-    ]);
-    const [, receipt] = await Promise.all([
-      wallet.waitForTransactionReceipt({ hash: permitTx }),
-      wallet.waitForTransactionReceipt({ hash: transferTx })
-    ]);
-    if (receipt.status !== "success") {
-      return {
-        success: false,
-        errorReason: "transaction_failed",
-        transaction: transferTx,
-        network: paymentPayload.network,
-        payer: owner
-      };
-    }
-    transactionHash = transferTx;
+  const receipt = await wallet.waitForTransactionReceipt({ hash: transactionHash });
+  if (receipt.status !== "success") {
+    return {
+      success: false,
+      errorReason: "transaction_failed",
+      transaction: transactionHash,
+      network: paymentPayload.network,
+      payer: owner
+    };
   }
   return {
     success: true,
@@ -2695,7 +2787,7 @@ function preparePaymentHeader(from, x402Version, paymentRequirements) {
       signature: void 0,
       authorization: {
         from,
-        to: paymentRequirements.extra?.relayer || paymentRequirements.payTo,
+        to: paymentRequirements.payTo,
         value: paymentRequirements.maxAmountRequired,
         validAfter: validAfter.toString(),
         validBefore: validBefore.toString(),
@@ -2753,7 +2845,7 @@ function preparePaymentHeader2(from, x402Version, paymentRequirements) {
       signature: void 0,
       authorization: {
         owner: from,
-        spender: paymentRequirements.extra?.relayer || paymentRequirements.payTo,
+        spender: paymentRequirements.payTo,
         value: paymentRequirements.maxAmountRequired,
         deadline
       }