@wtflabs/x402 0.0.1-beta.0 → 0.0.1-beta.10

package/dist/cjs/schemes/index.js

@@ -38,8 +38,11 @@ __export(exact_exports, {
 var evm_exports2 = {};
 __export(evm_exports2, {
   decodePayment: () => decodePayment,
+  detectTokenPaymentMethods: () => detectTokenPaymentMethods,
   eip3009: () => eip3009_exports,
   encodePayment: () => encodePayment,
+  getRecommendedPaymentMethod: () => getRecommendedPaymentMethod,
+  getTokenInfo: () => getTokenInfo,
   permit: () => permit_exports,
   permit2: () => permit2_exports,
   settle: () => settle4,
@@ -357,6 +360,21 @@ var permit2Types = {
     { name: "amount", type: "uint256" }
   ]
 };
+var permit2WitnessTypes = {
+  PermitWitnessTransferFrom: [
+    { name: "permitted", type: "TokenPermissions" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "witness", type: "Witness" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ],
+  Witness: [{ name: "to", type: "address" }]
+};
+var WITNESS_TYPE_STRING = "Witness(address to)";
 var permit2ABI = [
   {
     inputs: [
@@ -426,6 +444,45 @@ var permit2ABI = [
     outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
     stateMutability: "view",
     type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              { internalType: "address", name: "token", type: "address" },
+              { internalType: "uint256", name: "amount", type: "uint256" }
+            ],
+            internalType: "struct ISignatureTransfer.TokenPermissions",
+            name: "permitted",
+            type: "tuple"
+          },
+          { internalType: "uint256", name: "nonce", type: "uint256" },
+          { internalType: "uint256", name: "deadline", type: "uint256" }
+        ],
+        internalType: "struct ISignatureTransfer.PermitTransferFrom",
+        name: "permit",
+        type: "tuple"
+      },
+      {
+        components: [
+          { internalType: "address", name: "to", type: "address" },
+          { internalType: "uint256", name: "requestedAmount", type: "uint256" }
+        ],
+        internalType: "struct ISignatureTransfer.SignatureTransferDetails",
+        name: "transferDetails",
+        type: "tuple"
+      },
+      { internalType: "address", name: "owner", type: "address" },
+      { internalType: "bytes32", name: "witness", type: "bytes32" },
+      { internalType: "string", name: "witnessTypeString", type: "string" },
+      { internalType: "bytes", name: "signature", type: "bytes" }
+    ],
+    name: "permitWitnessTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
   }
 ];
 
@@ -1243,6 +1300,8 @@ var ErrorReasons = [
   "invalid_authorization_type",
   "invalid_permit_signature",
   "invalid_permit2_signature",
+  "invalid_permit2_witness_signature",
+  "witness_recipient_mismatch",
   "permit_expired",
   "permit2_expired",
   "permit2_not_approved",
@@ -1250,6 +1309,7 @@ var ErrorReasons = [
   "invalid_spender_address",
   "token_mismatch",
   "insufficient_payment_amount",
+  "insufficient_token_balance",
   "transaction_failed",
   "settlement_failed"
 ];
@@ -1292,7 +1352,9 @@ var Permit2EvmPayloadAuthorizationSchema = import_zod3.z.object({
   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)
+  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({
@@ -1524,6 +1586,264 @@ async function signAndSimulateTransaction(signer, transaction, rpc) {
   return simulateResult;
 }
 
+// src/types/shared/evm/permitProxyABI.ts
+var permitProxyContractABI = [
+  // settleWithPermit - 使用 EIP-2612 Permit 进行结算
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "payer",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "seller",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "deadline",
+        type: "uint256"
+      },
+      {
+        internalType: "uint8",
+        name: "v",
+        type: "uint8"
+      },
+      {
+        internalType: "bytes32",
+        name: "r",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32",
+        name: "s",
+        type: "bytes32"
+      }
+    ],
+    name: "settleWithPermit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // settleWithERC3009 - 使用 EIP-3009 TransferWithAuthorization 进行结算
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "payer",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "seller",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "validAfter",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "validBefore",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "nonce",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint8",
+        name: "v",
+        type: "uint8"
+      },
+      {
+        internalType: "bytes32",
+        name: "r",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32",
+        name: "s",
+        type: "bytes32"
+      }
+    ],
+    name: "settleWithERC3009",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // settleWithERC3009Direct - 直接结算（无手续费）
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "payer",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "seller",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "validAfter",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "validBefore",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "nonce",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint8",
+        name: "v",
+        type: "uint8"
+      },
+      {
+        internalType: "bytes32",
+        name: "r",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32",
+        name: "s",
+        type: "bytes32"
+      }
+    ],
+    name: "settleWithERC3009Direct",
+    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",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "feeAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "path",
+        type: "string"
+      }
+    ],
+    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"
+      }
+    ],
+    name: "SettledDirect",
+    type: "event"
+  }
+];
+
 // src/schemes/exact/evm/eip3009/facilitator.ts
 async function verify(client, payload, paymentRequirements) {
   const exactEvmPayload = payload.payload;
@@ -1588,7 +1908,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)) {
+  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)) {
     return {
       isValid: false,
       invalidReason: "invalid_exact_evm_payload_recipient_mismatch",
@@ -1661,21 +1981,57 @@ async function settle(wallet, paymentPayload, paymentRequirements) {
     };
   }
   const { signature } = (0, import_viem2.parseErc6492Signature)(payload.signature);
-  const 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
-  });
+  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
+        payload.authorization.to,
+        // 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 receipt = await wallet.waitForTransactionReceipt({ hash: tx });
   if (receipt.status !== "success") {
     return {
@@ -1719,11 +2075,7 @@ async function signPermit(walletClient, { owner, spender, value, deadline }, { a
         abi: erc20PermitABI,
         functionName: "name"
       }),
-      walletClient.readContract({
-        address: tokenAddress,
-        abi: erc20PermitABI,
-        functionName: "version"
-      })
+      getVersion(walletClient, tokenAddress)
     ]);
   } else {
     throw new Error("Local account signing for permit requires a connected client");
@@ -1773,63 +2125,6 @@ function splitSignature(signature) {
   return { v, r, s };
 }
 
-// src/types/shared/evm/permitProxyABI.ts
-var permitProxyContractABI = [
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "owner",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "spender",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "value",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "deadline",
-        type: "uint256"
-      },
-      {
-        internalType: "uint8",
-        name: "v",
-        type: "uint8"
-      },
-      {
-        internalType: "bytes32",
-        name: "r",
-        type: "bytes32"
-      },
-      {
-        internalType: "bytes32",
-        name: "s",
-        type: "bytes32"
-      },
-      {
-        internalType: "address",
-        name: "to",
-        type: "address"
-      }
-    ],
-    name: "permitAndTransfer",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  }
-];
-
 // src/schemes/exact/evm/permit/facilitator.ts
 async function verify2(client, payload, paymentRequirements) {
   if (payload.payload.authorizationType !== "permit" || payload.scheme !== SCHEME || paymentRequirements.scheme !== SCHEME) {
@@ -1897,8 +2192,8 @@ async function verify2(client, payload, paymentRequirements) {
       payer: owner
     };
   }
-  if (paymentRequirements.extra?.proxyAddress) {
-    if ((0, import_viem4.getAddress)(spender) !== (0, import_viem4.getAddress)(paymentRequirements.extra?.proxyAddress)) {
+  if (paymentRequirements.extra?.relayer) {
+    if ((0, import_viem4.getAddress)(spender) !== (0, import_viem4.getAddress)(paymentRequirements.extra?.relayer)) {
       return {
         isValid: false,
         invalidReason: "invalid_spender_address",
@@ -1962,21 +2257,28 @@ async function settle2(wallet, paymentPayload, paymentRequirements) {
     address: wallet.account.address
   });
   let transactionHash;
-  if (paymentRequirements.extra?.proxyAddress) {
+  if (paymentRequirements.extra?.relayer) {
     transactionHash = await wallet.writeContract({
-      address: paymentRequirements.extra.proxyAddress,
+      address: paymentRequirements.extra.relayer,
       abi: permitProxyContractABI,
-      functionName: "permitAndTransfer",
+      functionName: "settleWithPermit",
       args: [
         tokenAddress,
+        // token
         owner,
-        spender,
+        // payer
+        paymentRequirements.payTo,
+        // seller
         BigInt(value),
+        // amount
         BigInt(deadline),
+        // deadline
         v,
+        // v
         r,
-        s,
-        paymentRequirements.payTo
+        // r
+        s
+        // s
       ],
       chain: wallet.chain,
       nonce: txNonce
@@ -2045,11 +2347,41 @@ async function verify3(client, payload, paymentRequirements) {
     };
   }
   const permit2Payload = payload.payload;
-  const { owner, spender, token, amount, deadline, nonce } = permit2Payload.authorization;
+  const { owner, spender, token, amount, deadline, nonce, to } = permit2Payload.authorization;
   const chainId = getNetworkId(payload.network);
   const tokenAddress = (0, import_viem5.getAddress)(token);
   const ownerAddress = (0, import_viem5.getAddress)(owner);
-  const permit2TypedData = {
+  const hasWitness = !!to;
+  if (hasWitness) {
+    if ((0, import_viem5.getAddress)(to) !== (0, import_viem5.getAddress)(paymentRequirements.payTo)) {
+      return {
+        isValid: false,
+        invalidReason: "witness_recipient_mismatch",
+        payer: owner
+      };
+    }
+  }
+  const permit2TypedData = hasWitness ? {
+    types: permit2WitnessTypes,
+    domain: {
+      name: "Permit2",
+      chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    },
+    primaryType: "PermitWitnessTransferFrom",
+    message: {
+      permitted: {
+        token: tokenAddress,
+        amount
+      },
+      spender: (0, import_viem5.getAddress)(spender),
+      nonce,
+      deadline,
+      witness: {
+        to: (0, import_viem5.getAddress)(to)
+      }
+    }
+  } : {
     types: permit2Types,
     domain: {
       name: "Permit2",
@@ -2075,7 +2407,7 @@ async function verify3(client, payload, paymentRequirements) {
   if (!recoveredAddress) {
     return {
       isValid: false,
-      invalidReason: "invalid_permit2_signature",
+      invalidReason: hasWitness ? "invalid_permit2_witness_signature" : "invalid_permit2_signature",
       payer: owner
     };
   }
@@ -2150,10 +2482,34 @@ async function settle3(wallet, paymentPayload, paymentRequirements) {
       payer: permit2Payload.authorization.owner
     };
   }
-  const { owner, token, amount, deadline, nonce } = permit2Payload.authorization;
+  const { owner, token, amount, deadline, nonce, to } = permit2Payload.authorization;
   const tokenAddress = (0, import_viem5.getAddress)(token);
   const ownerAddress = (0, import_viem5.getAddress)(owner);
-  const tx = await wallet.writeContract({
+  const hasWitness = !!to;
+  const tx = hasWitness ? await wallet.writeContract({
+    address: PERMIT2_ADDRESS,
+    abi: permit2ABI,
+    functionName: "permitWitnessTransferFrom",
+    args: [
+      {
+        permitted: {
+          token: tokenAddress,
+          amount: BigInt(amount)
+        },
+        nonce: BigInt(nonce),
+        deadline: BigInt(deadline)
+      },
+      {
+        to: paymentRequirements.payTo,
+        requestedAmount: BigInt(amount)
+      },
+      ownerAddress,
+      (0, import_viem5.keccak256)((0, import_viem5.encodeAbiParameters)([{ type: "address", name: "to" }], [(0, import_viem5.getAddress)(to)])),
+      WITNESS_TYPE_STRING,
+      permit2Payload.signature
+    ],
+    chain: wallet.chain
+  }) : await wallet.writeContract({
     address: PERMIT2_ADDRESS,
     abi: permit2ABI,
     functionName: "permitTransferFrom",
@@ -2339,7 +2695,7 @@ function preparePaymentHeader(from, x402Version, paymentRequirements) {
       signature: void 0,
       authorization: {
         from,
-        to: paymentRequirements.payTo,
+        to: paymentRequirements.extra?.relayer || paymentRequirements.payTo,
         value: paymentRequirements.maxAmountRequired,
         validAfter: validAfter.toString(),
         validBefore: validBefore.toString(),
@@ -2397,7 +2753,7 @@ function preparePaymentHeader2(from, x402Version, paymentRequirements) {
       signature: void 0,
       authorization: {
         owner: from,
-        spender: paymentRequirements.payTo,
+        spender: paymentRequirements.extra?.relayer || paymentRequirements.payTo,
         value: paymentRequirements.maxAmountRequired,
         deadline
       }
@@ -2451,13 +2807,34 @@ __export(permit2_exports, {
 
 // src/schemes/exact/evm/permit2/sign.ts
 var import_viem7 = require("viem");
-async function signPermit2(walletClient, { owner, spender, token, amount, deadline }, { network }) {
+async function signPermit2(walletClient, { owner, spender, token, amount, deadline, to }, { network }) {
   const chainId = getNetworkId(network);
   const tokenAddress = (0, import_viem7.getAddress)(token);
   const ownerAddress = (0, import_viem7.getAddress)(owner);
   const spenderAddress = (0, import_viem7.getAddress)(spender);
   const nonce = await createPermit2Nonce(walletClient, ownerAddress);
-  const data = {
+  const hasWitness = !!to;
+  const data = hasWitness ? {
+    types: permit2WitnessTypes,
+    domain: {
+      name: "Permit2",
+      chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    },
+    primaryType: "PermitWitnessTransferFrom",
+    message: {
+      permitted: {
+        token: tokenAddress,
+        amount: BigInt(amount)
+      },
+      spender: spenderAddress,
+      nonce,
+      deadline: BigInt(deadline),
+      witness: {
+        to: (0, import_viem7.getAddress)(to)
+      }
+    }
+  } : {
     types: permit2Types,
     domain: {
       name: "Permit2",
@@ -2535,16 +2912,18 @@ function preparePaymentHeader3(from, x402Version, paymentRequirements) {
         spender: paymentRequirements.payTo,
         token: paymentRequirements.asset,
         amount: paymentRequirements.maxAmountRequired,
-        deadline
+        deadline,
+        to: paymentRequirements.payTo
+        // Witness: bind recipient to signature
       }
     }
   };
 }
 async function signPaymentHeader3(client, paymentRequirements, unsignedPaymentHeader) {
-  const { owner, spender, token, amount, deadline } = unsignedPaymentHeader.payload.authorization;
+  const { owner, spender, token, amount, deadline, to } = unsignedPaymentHeader.payload.authorization;
   const { signature, nonce } = await signPermit2(
     client,
-    { owner, spender, token, amount, deadline },
+    { owner, spender, token, amount, deadline, to },
     paymentRequirements
   );
   return {
@@ -2558,7 +2937,9 @@ async function signPaymentHeader3(client, paymentRequirements, unsignedPaymentHe
         token,
         amount,
         deadline,
-        nonce
+        nonce,
+        ...to ? { to } : {}
+        // Include `to` field if present (witness mode)
       }
     }
   };
@@ -2573,6 +2954,158 @@ async function createPaymentHeader3(client, x402Version, paymentRequirements) {
   return encodePayment(payment);
 }
 
+// src/schemes/exact/evm/utils/tokenDetection.ts
+var EIP3009_SIGNATURES = ["0xe3ee160e", "0xcf092995"];
+var EIP2612_PERMIT = "0xd505accf";
+var PERMIT2_ADDRESS2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+async function hasMethod(client, tokenAddress, methodSelector) {
+  try {
+    const code = await client.getBytecode({ address: tokenAddress });
+    if (!code) return false;
+    return code.toLowerCase().includes(methodSelector.slice(2).toLowerCase());
+  } catch (error) {
+    console.error(`Error checking method ${methodSelector}:`, error);
+    return false;
+  }
+}
+async function hasAnyMethod(client, tokenAddress, methodSelectors) {
+  try {
+    const code = await client.getBytecode({ address: tokenAddress });
+    if (!code) return false;
+    const codeLower = code.toLowerCase();
+    return methodSelectors.some((selector) => codeLower.includes(selector.slice(2).toLowerCase()));
+  } catch (error) {
+    console.error(`Error checking methods ${methodSelectors.join(", ")}:`, error);
+    return false;
+  }
+}
+async function checkPermit2Support(client) {
+  try {
+    const permit2Code = await client.getBytecode({ address: PERMIT2_ADDRESS2 });
+    if (!permit2Code) return false;
+    return true;
+  } catch (error) {
+    console.error("Error checking Permit2 support:", error);
+    return false;
+  }
+}
+async function detectTokenPaymentMethods(tokenAddress, client) {
+  const address = tokenAddress.toLowerCase();
+  console.log(`\u{1F50D} Detecting payment methods for token ${address}...`);
+  const [hasEIP3009, hasPermit, hasPermit2Approval] = await Promise.all([
+    hasAnyMethod(client, address, EIP3009_SIGNATURES),
+    hasMethod(client, address, EIP2612_PERMIT),
+    checkPermit2Support(client)
+  ]);
+  const supportedMethods = [];
+  if (hasEIP3009) {
+    supportedMethods.push("eip3009");
+    console.log("  \u2705 EIP-3009 (transferWithAuthorization) detected");
+  }
+  if (hasPermit) {
+    supportedMethods.push("permit");
+    console.log("  \u2705 EIP-2612 (permit) detected");
+  }
+  if (hasPermit2Approval) {
+    supportedMethods.push("permit2");
+    supportedMethods.push("permit2-witness");
+    console.log("  \u2705 Permit2 support available (universal)");
+  }
+  if (supportedMethods.length === 0) {
+    console.log("  \u26A0\uFE0F  No advanced payment methods detected (standard ERC-20 only)");
+  }
+  return {
+    address,
+    supportedMethods,
+    details: {
+      hasEIP3009,
+      hasPermit,
+      hasPermit2Approval
+    }
+  };
+}
+async function getRecommendedPaymentMethod(tokenAddress, client) {
+  const capabilities = await detectTokenPaymentMethods(tokenAddress, client);
+  const { supportedMethods } = capabilities;
+  if (supportedMethods.includes("eip3009")) return "eip3009";
+  if (supportedMethods.includes("permit")) return "permit";
+  if (supportedMethods.includes("permit2") || supportedMethods.includes("permit2-witness")) {
+    return "permit2";
+  }
+  return null;
+}
+async function getTokenInfo(tokenAddress, client) {
+  const address = tokenAddress.toLowerCase();
+  const erc20ABI = [
+    {
+      inputs: [],
+      name: "name",
+      outputs: [{ name: "", type: "string" }],
+      stateMutability: "view",
+      type: "function"
+    }
+  ];
+  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 versionABI = [
+    {
+      inputs: [],
+      name: "version",
+      outputs: [{ name: "", type: "string" }],
+      stateMutability: "view",
+      type: "function"
+    }
+  ];
+  try {
+    const name = await client.readContract({
+      address,
+      abi: erc20ABI,
+      functionName: "name"
+    });
+    let version = "1";
+    try {
+      const result = await client.readContract({
+        address,
+        abi: eip712DomainABI,
+        functionName: "eip712Domain"
+      });
+      version = result[2];
+    } catch {
+      try {
+        version = await client.readContract({
+          address,
+          abi: versionABI,
+          functionName: "version"
+        });
+      } catch {
+        console.log(`  \u2139\uFE0F  Using default version "1" for token ${address}`);
+      }
+    }
+    return {
+      name,
+      version
+    };
+  } catch (error) {
+    console.error(`Error getting token info for ${address}:`, error);
+    throw new Error(`Failed to get token info: ${error}`);
+  }
+}
+
 // src/schemes/exact/evm/index.ts
 async function verify4(client, payload, paymentRequirements) {
   const exactEvmPayload = payload.payload;