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

package/dist/cjs/schemes/index.d.ts

@@ -353,27 +353,30 @@ interface TokenPaymentCapabilities {
     };
 }
 /**
- * detect the payment methods supported by the token
+ * Detect the payment methods supported by the token
  *
  * @param tokenAddress - token address
  * @param client - viem PublicClient
- * @returns the payment capabilities of the token
+ * @returns detection result
  */
 declare function detectTokenPaymentMethods(tokenAddress: string, client: PublicClient): Promise<TokenPaymentCapabilities>;
 /**
- * get the recommended payment method for the token
+ * Get the recommended payment method (only return types supported by the schema)
+ * Sort by priority: eip3009 > permit > permit2
+ * Note: permit2-witness is mapped to permit2 because they are the same payment type in the schema
  *
  * @param tokenAddress - token address
  * @param client - viem PublicClient
- * @returns the recommended payment method
+ * @returns recommended payment method
  */
-declare function getRecommendedPaymentMethod(tokenAddress: string, client: PublicClient): Promise<"eip3009" | "permit" | "permit2" | null>;
+declare function getRecommendedPaymentMethod(tokenAddress: string, client: PublicClient): Promise<"eip3009" | "permit2" | "permit" | null>;
 /**
- * get the name and version information of the token (for EIP-712 signing)
+ * Get the name and version information of the token (for EIP-712 signing)
+ * Supports proxy contracts (will automatically read from the proxy contract, because the proxy contract will delegatecall to the implementation contract)
  *
  * @param tokenAddress - token address
  * @param client - viem PublicClient
- * @returns the name and version information of the token
+ * @returns name and version information of the token
  */
 declare function getTokenInfo(tokenAddress: string, client: PublicClient): Promise<TokenInfo>;
 

package/dist/cjs/schemes/index.js

@@ -1996,7 +1996,7 @@ async function settle(wallet, paymentPayload, paymentRequirements) {
         // token
         payload.authorization.from,
         // payer
-        payload.authorization.to,
+        paymentRequirements.payTo,
         // seller
         BigInt(payload.authorization.value),
         // amount
@@ -2955,14 +2955,104 @@ async function createPaymentHeader3(client, x402Version, paymentRequirements) {
 }
 
 // src/schemes/exact/evm/utils/tokenDetection.ts
+var paymentMethodsCache = /* @__PURE__ */ new Map();
+var recommendedMethodCache = /* @__PURE__ */ new Map();
+var PRESET_TOKEN_CAPABILITIES = {
+  // World Liberty Financial USD - 只支持 permit
+  "0x8d0d000ee44948fc98c9b98a4fa4921476f08b0d": {
+    supportedMethods: ["permit"],
+    supportedNetworks: [56],
+    description: "World Liberty Financial USD (WLFI)"
+  }
+  // 可以继续添加更多预设代币
+  // 示例：
+  // "0x其他代币地址": {
+  //   supportedMethods: ["eip3009", "permit"],
+  //   description: "代币名称",
+  // },
+};
 var EIP3009_SIGNATURES = ["0xe3ee160e", "0xcf092995"];
 var EIP2612_PERMIT = "0xd505accf";
 var PERMIT2_ADDRESS2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var EIP1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+var EIP1822_IMPLEMENTATION_SLOT = "0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3";
+async function getImplementationAddress(client, proxyAddress) {
+  try {
+    try {
+      const implSlotData = await client.getStorageAt({
+        address: proxyAddress,
+        slot: EIP1967_IMPLEMENTATION_SLOT
+      });
+      if (implSlotData && implSlotData !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        const implAddress = `0x${implSlotData.slice(-40)}`;
+        if (implAddress !== "0x0000000000000000000000000000000000000000") {
+          console.log(`  \u{1F4E6} Detected EIP-1967 proxy, implementation: ${implAddress}`);
+          return implAddress;
+        }
+      }
+    } catch {
+    }
+    try {
+      const uupsSlotData = await client.getStorageAt({
+        address: proxyAddress,
+        slot: EIP1822_IMPLEMENTATION_SLOT
+      });
+      if (uupsSlotData && uupsSlotData !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        const implAddress = `0x${uupsSlotData.slice(-40)}`;
+        if (implAddress !== "0x0000000000000000000000000000000000000000") {
+          console.log(`  \u{1F4E6} Detected EIP-1822 UUPS proxy, implementation: ${implAddress}`);
+          return implAddress;
+        }
+      }
+    } catch {
+    }
+    try {
+      const implABI = [
+        {
+          inputs: [],
+          name: "implementation",
+          outputs: [{ name: "", type: "address" }],
+          stateMutability: "view",
+          type: "function"
+        }
+      ];
+      const implAddress = await client.readContract({
+        address: proxyAddress,
+        abi: implABI,
+        functionName: "implementation"
+      });
+      if (implAddress && implAddress !== "0x0000000000000000000000000000000000000000") {
+        console.log(`  \u{1F4E6} Detected proxy via implementation(), implementation: ${implAddress}`);
+        return implAddress;
+      }
+    } catch {
+    }
+    return null;
+  } catch (error) {
+    console.error("Error detecting proxy implementation:", error);
+    return null;
+  }
+}
 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());
+    const hasMethodInProxy = code.toLowerCase().includes(methodSelector.slice(2).toLowerCase());
+    if (hasMethodInProxy) {
+      return true;
+    }
+    const implAddress = await getImplementationAddress(client, tokenAddress);
+    if (implAddress) {
+      const implCode = await client.getBytecode({ address: implAddress });
+      if (implCode) {
+        const hasMethodInImpl = implCode.toLowerCase().includes(methodSelector.slice(2).toLowerCase());
+        if (hasMethodInImpl) {
+          console.log(`  \u2705 Method ${methodSelector} found in implementation contract`);
+        }
+        return hasMethodInImpl;
+      }
+    }
+    return false;
   } catch (error) {
     console.error(`Error checking method ${methodSelector}:`, error);
     return false;
@@ -2973,7 +3063,27 @@ async function hasAnyMethod(client, tokenAddress, methodSelectors) {
     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()));
+    const hasMethodInProxy = methodSelectors.some(
+      (selector) => codeLower.includes(selector.slice(2).toLowerCase())
+    );
+    if (hasMethodInProxy) {
+      return true;
+    }
+    const implAddress = await getImplementationAddress(client, tokenAddress);
+    if (implAddress) {
+      const implCode = await client.getBytecode({ address: implAddress });
+      if (implCode) {
+        const implCodeLower = implCode.toLowerCase();
+        const hasMethodInImpl = methodSelectors.some(
+          (selector) => implCodeLower.includes(selector.slice(2).toLowerCase())
+        );
+        if (hasMethodInImpl) {
+          console.log(`  \u2705 Method(s) found in implementation contract`);
+        }
+        return hasMethodInImpl;
+      }
+    }
+    return false;
   } catch (error) {
     console.error(`Error checking methods ${methodSelectors.join(", ")}:`, error);
     return false;
@@ -2991,6 +3101,48 @@ async function checkPermit2Support(client) {
 }
 async function detectTokenPaymentMethods(tokenAddress, client) {
   const address = tokenAddress.toLowerCase();
+  const chainId = await client.getChainId();
+  const cacheKey = `${chainId}:${address}`;
+  const cached = paymentMethodsCache.get(cacheKey);
+  if (cached) {
+    console.log(`\u{1F4BE} Using cached payment methods for token ${address}`);
+    return cached;
+  }
+  const presetCapabilities = PRESET_TOKEN_CAPABILITIES[address];
+  if (presetCapabilities) {
+    if (!chainId || !presetCapabilities.supportedNetworks.includes(chainId)) {
+      return {
+        address,
+        supportedMethods: [],
+        details: {
+          hasEIP3009: false,
+          hasPermit: false,
+          hasPermit2Approval: false
+        }
+      };
+    }
+    const hasEIP30092 = presetCapabilities.supportedMethods.includes("eip3009");
+    const hasPermit2 = presetCapabilities.supportedMethods.includes("permit");
+    const hasPermit2Approval2 = presetCapabilities.supportedMethods.includes("permit2") || presetCapabilities.supportedMethods.includes("permit2-witness");
+    if (hasEIP30092) {
+      console.log("  \u2705 EIP-3009 (transferWithAuthorization) - from preset");
+    }
+    if (hasPermit2) {
+      console.log("  \u2705 EIP-2612 (permit) - from preset");
+    }
+    if (hasPermit2Approval2) {
+      console.log("  \u2705 Permit2 support - from preset");
+    }
+    return {
+      address,
+      supportedMethods: presetCapabilities.supportedMethods,
+      details: {
+        hasEIP3009: hasEIP30092,
+        hasPermit: hasPermit2,
+        hasPermit2Approval: hasPermit2Approval2
+      }
+    };
+  }
   console.log(`\u{1F50D} Detecting payment methods for token ${address}...`);
   const [hasEIP3009, hasPermit, hasPermit2Approval] = await Promise.all([
     hasAnyMethod(client, address, EIP3009_SIGNATURES),
@@ -3014,7 +3166,7 @@ async function detectTokenPaymentMethods(tokenAddress, client) {
   if (supportedMethods.length === 0) {
     console.log("  \u26A0\uFE0F  No advanced payment methods detected (standard ERC-20 only)");
   }
-  return {
+  const result = {
     address,
     supportedMethods,
     details: {
@@ -3023,16 +3175,30 @@ async function detectTokenPaymentMethods(tokenAddress, client) {
       hasPermit2Approval
     }
   };
+  paymentMethodsCache.set(cacheKey, result);
+  return result;
 }
 async function getRecommendedPaymentMethod(tokenAddress, client) {
+  const address = tokenAddress.toLowerCase();
+  const chainId = await client.getChainId();
+  const cacheKey = `${chainId}:${address}`;
+  const cached = recommendedMethodCache.get(cacheKey);
+  if (cached !== void 0) {
+    console.log(`\u{1F4BE} Using cached recommended method for token ${address}`);
+    return cached;
+  }
   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";
+  let result = null;
+  if (supportedMethods.includes("eip3009")) {
+    result = "eip3009";
+  } else if (supportedMethods.includes("permit")) {
+    result = "permit";
+  } else if (supportedMethods.includes("permit2") || supportedMethods.includes("permit2-witness")) {
+    result = "permit2";
   }
-  return null;
+  recommendedMethodCache.set(cacheKey, result);
+  return result;
 }
 async function getTokenInfo(tokenAddress, client) {
   const address = tokenAddress.toLowerCase();
@@ -3072,6 +3238,12 @@ async function getTokenInfo(tokenAddress, client) {
     }
   ];
   try {
+    const implAddress = await getImplementationAddress(client, address);
+    if (implAddress) {
+      console.log(
+        `  \u{1F4E6} Reading token info from proxy, actual calls will be delegated to implementation`
+      );
+    }
     const name = await client.readContract({
       address,
       abi: erc20ABI,