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

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
@@ -2958,11 +2958,85 @@ async function createPaymentHeader3(client, x402Version, paymentRequirements) {
 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 +3047,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;
@@ -3072,6 +3166,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,