@wtflabs/x402-server 0.0.1-beta.6 → 0.0.1-beta.9

package/dist/index.mjs

@@ -1,610 +0,0 @@
-// src/token-detection.ts
-var EIP3009_SIGNATURES = ["0xe3ee160e", "0xcf092995"];
-var EIP2612_PERMIT = "0xd505accf";
-var PERMIT2_ADDRESS = "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;
-    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;
-  }
-}
-async function hasAnyMethod(client, tokenAddress, methodSelectors) {
-  try {
-    const code = await client.getBytecode({ address: tokenAddress });
-    if (!code) return false;
-    const codeLower = code.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;
-  }
-}
-async function checkPermit2Support(client) {
-  try {
-    const permit2Code = await client.getBytecode({ address: PERMIT2_ADDRESS });
-    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
-    }
-  };
-}
-function getRecommendedPaymentMethod(capabilities) {
-  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 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,
-      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/server.ts
-var X402Server = class {
-  constructor(config) {
-    this.initialized = false;
-    this.facilitator = config.facilitator;
-    this.schema = config.schema;
-    this.client = config.client;
-    this._initialize();
-  }
-  async _initialize() {
-    try {
-      this.schema.verify();
-      const schemaAsset = this.schema.get("asset");
-      if (schemaAsset) {
-        try {
-          const tokenInfo = await getTokenInfo(schemaAsset, this.client);
-          this.schema.setExtra({
-            relayer: this.facilitator.relayer,
-            name: tokenInfo.name,
-            version: tokenInfo.version
-          });
-          console.log(`\u2705 Token info retrieved: ${tokenInfo.name} v${tokenInfo.version}`);
-        } catch (error) {
-          console.warn(`\u26A0\uFE0F  Failed to get token info, signatures may fail:`, error);
-          this.schema.setExtra({
-            relayer: this.facilitator.relayer
-          });
-        }
-      } else {
-        this.schema.setExtra({
-          relayer: this.facilitator.relayer
-        });
-      }
-      const verifyResult = await this._verify();
-      if (!verifyResult.success) {
-        return {
-          success: false,
-          error: verifyResult.errors?.[0] || "Verification failed"
-        };
-      }
-      this.initialized = true;
-      return { success: true };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Initialization failed"
-      };
-    }
-  }
-  /**
-   * 验证配置
-   * 1. 验证 client network 是否和 schema 的 network 匹配
-   * 2. 验证 facilitator recipientAddress 和 schema payTo 是否一致
-   */
-  async _verify() {
-    const errors = [];
-    try {
-      const schemaAsset = this.schema.get("asset");
-      if (schemaAsset) {
-        const tokenCapabilities = await detectTokenPaymentMethods(
-          schemaAsset,
-          this.client
-        );
-        const currentPaymentType = this.schema.get("paymentType");
-        if (!currentPaymentType) {
-          const recommendedMethod = getRecommendedPaymentMethod(tokenCapabilities);
-          if (recommendedMethod) {
-            this.schema.set("paymentType", recommendedMethod);
-          } else {
-            errors.push(
-              `Token ${schemaAsset} does not support any advanced payment methods (permit, eip3009, permit2). Please specify paymentType manually.`
-            );
-          }
-        } else {
-          if (!tokenCapabilities.supportedMethods.includes(currentPaymentType)) {
-            errors.push(
-              `Token ${schemaAsset} does not support the specified payment method "${currentPaymentType}". Supported methods: ${tokenCapabilities.supportedMethods.join(", ")}`
-            );
-          }
-        }
-        if (tokenCapabilities.supportedMethods.length === 0) {
-          errors.push(
-            `Token ${schemaAsset} does not support any advanced payment methods (permit, eip3009, permit2)`
-          );
-        }
-      }
-      const clientChainId = this.client.chain?.id;
-      const schemaNetwork = this.schema.get("network");
-      if (clientChainId && schemaAsset) {
-        const facilitatorSupported = await this.facilitator.supported({
-          chainId: clientChainId,
-          tokenAddress: schemaAsset
-        });
-        const isSupportedByFacilitator = facilitatorSupported.kinds.some(
-          (kind) => {
-            const networkMatches = kind.network === schemaNetwork;
-            const assetsInKind = kind.extra?.assets || [];
-            const assetMatches = assetsInKind.some(
-              (asset) => asset.address.toLowerCase() === schemaAsset.toLowerCase()
-            );
-            return networkMatches && assetMatches;
-          }
-        );
-        if (!isSupportedByFacilitator) {
-          errors.push(
-            `Facilitator does not support token ${schemaAsset} on network ${schemaNetwork} (chainId: ${clientChainId})`
-          );
-        } else {
-        }
-        const chainSupported = facilitatorSupported.kinds.some(
-          (kind) => kind.network === schemaNetwork
-        );
-        if (!chainSupported) {
-          errors.push(
-            `Facilitator does not support network ${schemaNetwork} (chainId: ${clientChainId})`
-          );
-        }
-      }
-      if (clientChainId) {
-        const networkValid = this.validateNetwork(
-          schemaNetwork,
-          clientChainId
-        );
-        if (!networkValid) {
-          errors.push(
-            `Network mismatch: client chainId ${clientChainId} does not match schema network ${schemaNetwork}`
-          );
-        }
-      }
-      const schemaPayTo = this.schema.get("payTo");
-      const facilitatorRecipientAddress = this.facilitator.recipientAddress;
-      if (schemaPayTo.toLowerCase() !== facilitatorRecipientAddress.toLowerCase()) {
-        errors.push(
-          `Address mismatch: schema payTo ${schemaPayTo} does not match facilitator recipientAddress ${facilitatorRecipientAddress}`
-        );
-      }
-      return {
-        success: errors.length === 0,
-        errors: errors.length > 0 ? errors : void 0
-      };
-    } catch (error) {
-      errors.push(
-        error instanceof Error ? error.message : "Unknown verification error"
-      );
-      return {
-        success: false,
-        errors
-      };
-    }
-  }
-  /**
-   * 结算支付
-   * @param paymentPayload 支付负载
-   * @param paymentRequirements 支付要求
-   */
-  async settle(paymentPayload, paymentRequirements) {
-    if (!this.initialized) {
-      return {
-        success: false,
-        error: "Server not initialized. Please call initialize() first."
-      };
-    }
-    try {
-      const result = await this.facilitator.settle(
-        paymentPayload,
-        paymentRequirements
-      );
-      if (!result.success) {
-        return {
-          success: false,
-          error: result.error || result.errorMessage
-        };
-      }
-      return {
-        success: true,
-        transaction: result.transaction
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Settlement failed"
-      };
-    }
-  }
-  /**
-   * 验证支付负载
-   * @param paymentPayload 支付负载
-   * @param paymentRequirements 支付要求
-   */
-  async verify(paymentPayload, paymentRequirements) {
-    if (!this.initialized) {
-      return {
-        success: false,
-        error: "Server not initialized. Please call initialize() first."
-      };
-    }
-    try {
-      const result = await this.facilitator.verify(
-        paymentPayload,
-        paymentRequirements
-      );
-      return {
-        success: result.success,
-        data: result.payer,
-        error: result.error || result.errorMessage
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Payment verification failed"
-      };
-    }
-  }
-  /**
-   * 获取 facilitator
-   */
-  getFacilitator() {
-    return this.facilitator;
-  }
-  /**
-   * 获取 schema
-   */
-  getSchema() {
-    return this.schema;
-  }
-  /**
-   * 获取 client
-   */
-  getClient() {
-    return this.client;
-  }
-  /**
-   * 检查是否已初始化
-   */
-  isInitialized() {
-    return this.initialized;
-  }
-  /**
-   * 验证网络是否匹配
-   * @param schemaNetwork schema 中的 network
-   * @param clientChainId client 的 chainId
-   * @returns 是否匹配
-   */
-  validateNetwork(schemaNetwork, clientChainId) {
-    if (schemaNetwork.startsWith("eip155:")) {
-      const chainId = parseInt(schemaNetwork.split(":")[1] || "0");
-      return chainId === clientChainId;
-    }
-    const networkMap = {
-      "ethereum": 1,
-      "goerli": 5,
-      "sepolia": 11155111,
-      "base": 8453,
-      "base-sepolia": 84532,
-      "bsc": 56,
-      "bsc-testnet": 97,
-      "polygon": 137,
-      "polygon-mumbai": 80001,
-      "arbitrum": 42161,
-      "arbitrum-goerli": 421613,
-      "optimism": 10,
-      "optimism-goerli": 420,
-      "avalanche": 43114,
-      "avalanche-fuji": 43113
-    };
-    const expectedChainId = networkMap[schemaNetwork];
-    if (expectedChainId !== void 0) {
-      return expectedChainId === clientChainId;
-    }
-    return true;
-  }
-  /**
-   * 解析支付 header
-   * @param paymentHeaderBase64 Base64 编码的支付 header
-   * @returns 解析结果，成功时返回 paymentPayload 和 paymentRequirements，失败时返回服务端的支付要求
-   */
-  parsePaymentHeader(paymentHeaderBase64) {
-    const paymentRequirements = this.schema.toJSON();
-    if (!paymentHeaderBase64) {
-      return {
-        success: false,
-        data: paymentRequirements,
-        error: "No X-PAYMENT header"
-      };
-    }
-    let paymentPayload;
-    try {
-      const paymentHeaderJson = Buffer.from(
-        paymentHeaderBase64,
-        "base64"
-      ).toString("utf-8");
-      paymentPayload = JSON.parse(paymentHeaderJson);
-    } catch (err) {
-      return {
-        success: false,
-        data: paymentRequirements,
-        error: "Invalid payment header format"
-      };
-    }
-    const validationError = this.validatePaymentPayload(
-      paymentPayload,
-      paymentRequirements
-    );
-    if (validationError) {
-      return {
-        success: false,
-        data: paymentRequirements,
-        error: validationError
-      };
-    }
-    return {
-      success: true,
-      data: {
-        paymentPayload,
-        paymentRequirements
-      }
-    };
-  }
-  /**
-   * 验证客户端的支付数据是否与服务端要求一致
-   * @param paymentPayload 客户端的支付负载
-   * @param paymentRequirements 服务端的支付要求
-   * @returns 错误信息，如果验证通过则返回 null
-   */
-  validatePaymentPayload(paymentPayload, paymentRequirements) {
-    if (paymentPayload.scheme !== paymentRequirements.scheme) {
-      return `Scheme mismatch: expected '${paymentRequirements.scheme}', got '${paymentPayload.scheme}'`;
-    }
-    if (paymentPayload.network !== paymentRequirements.network) {
-      return `Network mismatch: expected '${paymentRequirements.network}', got '${paymentPayload.network}'`;
-    }
-    if (paymentPayload.payload) {
-      const authorization = paymentPayload.payload.authorization;
-      if (authorization?.value) {
-        const paymentAmount = BigInt(authorization.value);
-        const maxAmount = BigInt(paymentRequirements.maxAmountRequired);
-        if (paymentAmount !== maxAmount) {
-          return `Payment amount error ${paymentAmount} !== ${maxAmount}`;
-        }
-      }
-      if (authorization?.to) {
-        const expectedPayTo = paymentRequirements.payTo.toLowerCase();
-        const actualPayTo = authorization.to.toLowerCase();
-        if (actualPayTo !== expectedPayTo && actualPayTo !== paymentRequirements.extra?.relayer?.toLowerCase()) {
-          return `PayTo address mismatch: expected '${expectedPayTo}', got '${actualPayTo}'`;
-        }
-      }
-      const authorizationType = paymentPayload.payload.authorizationType;
-      if (authorizationType === "permit" || authorizationType === "permit2" || authorizationType === "eip3009") {
-      }
-    }
-    return null;
-  }
-};
-export {
-  X402Server,
-  detectTokenPaymentMethods,
-  getRecommendedPaymentMethod,
-  getTokenInfo
-};
-//# sourceMappingURL=index.mjs.map