@wtflabs/x402-detector 0.0.1-beta.2

package/dist/esm/index.d.mts

@@ -0,0 +1,209 @@
+import { PublicClient, Address } from 'viem';
+
+/**
+ * 支持的支付方式
+ */
+type PaymentMethod = "eip3009" | "permit" | "permit2" | "permit2-witness";
+/**
+ * Token 信息
+ */
+interface TokenInfo {
+    name: string;
+    version: string;
+}
+/**
+ * Token 支付能力检测结果
+ */
+interface TokenPaymentCapabilities {
+    /** Token 地址 */
+    address: string;
+    /** 支持的支付方式列表 */
+    supportedMethods: PaymentMethod[];
+    /** 详细检测结果 */
+    details: {
+        /** 是否支持 EIP-3009 (transferWithAuthorization) */
+        hasEIP3009: boolean;
+        /** 是否支持 EIP-2612 (permit) */
+        hasPermit: boolean;
+        /** 是否支持 Permit2 (通用授权) */
+        hasPermit2Approval: boolean;
+    };
+}
+/**
+ * 完整的 Token 检测结果（包含 name 和 version）
+ */
+interface TokenDetectionResult extends TokenPaymentCapabilities {
+    /** Token 名称 */
+    name: string;
+    /** Token version（用于 EIP-712 签名） */
+    version: string;
+}
+/**
+ * 预设 Token 配置
+ */
+interface PresetTokenConfig {
+    /** 支持的支付方式 */
+    supportedMethods: PaymentMethod[];
+    /** 支持的网络 ID 列表 */
+    supportedNetworks: number[];
+    /** Token 描述（可选） */
+    description?: string;
+}
+/**
+ * Logger 接口
+ */
+interface Logger {
+    log: (message: string) => void;
+    error: (message: string, error?: unknown) => void;
+}
+/**
+ * TokenDetector 配置选项
+ */
+interface TokenDetectorOptions {
+    /** 自定义 logger，默认使用 console */
+    logger?: Logger | null;
+}
+
+/**
+ * EIP-3009 方法签名
+ * - transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)
+ *
+ * 支持多个方法签名变体，以兼容不同的实现：
+ * - 0xe3ee160e: 标准 EIP-3009 实现
+ * - 0xcf092995: 某些代币的替代实现
+ */
+declare const EIP3009_SIGNATURES: readonly ["0xe3ee160e", "0xcf092995"];
+/**
+ * EIP-2612 Permit 方法签名
+ * - permit(address,address,uint256,uint256,uint8,bytes32,bytes32)
+ */
+declare const EIP2612_PERMIT: "0xd505accf";
+/**
+ * Uniswap Permit2 合约地址（所有链相同）
+ */
+declare const PERMIT2_ADDRESS: "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/**
+ * EIP-1967 标准实现槽位
+ * keccak256("eip1967.proxy.implementation") - 1
+ */
+declare const EIP1967_IMPLEMENTATION_SLOT: "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+/**
+ * EIP-1822 UUPS 实现槽位
+ * keccak256("PROXIABLE")
+ */
+declare const EIP1822_IMPLEMENTATION_SLOT: "0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3";
+/**
+ * 预设 Token 配置
+ * 用于已知的特殊 Token，避免重复检测
+ */
+declare const PRESET_TOKEN_CAPABILITIES: Record<string, PresetTokenConfig>;
+
+/**
+ * 检测 Token 支持的支付方式
+ *
+ * @param tokenAddress - Token 地址
+ * @param client - viem PublicClient
+ * @param logger - 可选的 logger
+ * @returns 检测结果
+ */
+declare function detectTokenPaymentMethods(tokenAddress: string, client: PublicClient, logger?: Logger | null): Promise<TokenPaymentCapabilities>;
+/**
+ * 获取推荐的支付方式（仅返回 schema 支持的类型）
+ * 按优先级排序：eip3009 > permit > permit2
+ * 注意：permit2-witness 会被映射为 permit2，因为它们在 schema 中是同一种支付类型
+ *
+ * @param tokenAddress - Token 地址
+ * @param client - viem PublicClient
+ * @param logger - 可选的 logger
+ * @returns 推荐的支付方式
+ */
+declare function getRecommendedPaymentMethod(tokenAddress: string, client: PublicClient, logger?: Logger | null): Promise<"eip3009" | "permit2" | "permit" | null>;
+/**
+ * 获取 Token 的 name 和 version 信息（用于 EIP-712 签名）
+ * 支持代理合约（会自动从代理合约读取，因为代理合约会 delegatecall 到实现合约）
+ *
+ * @param tokenAddress - Token 地址
+ * @param client - viem PublicClient
+ * @param logger - 可选的 logger
+ * @returns Token 的 name 和 version
+ */
+declare function getTokenInfo(tokenAddress: string, client: PublicClient, logger?: Logger | null): Promise<TokenInfo>;
+
+/**
+ * 检测合约是否是代理合约，并获取实现合约地址
+ *
+ * @param client - viem PublicClient
+ * @param proxyAddress - 代理合约地址
+ * @param logger - 可选的 logger
+ * @returns 实现合约地址或 null
+ */
+declare function getImplementationAddress(client: PublicClient, proxyAddress: Address, logger?: Logger | null): Promise<Address | null>;
+
+/**
+ * Token 检测器 - 带缓存功能的 SDK
+ *
+ * 主要用于 x402-server，也可以独立使用
+ */
+declare class TokenDetector {
+    /** 缓存存储 (chainId:address -> TokenDetectionResult) */
+    private cache;
+    /** viem PublicClient */
+    private client;
+    /** Logger 实例 */
+    private logger;
+    /**
+     * 构造函数
+     *
+     * @param client - viem PublicClient
+     * @param options - 可选配置
+     */
+    constructor(client: PublicClient, options?: TokenDetectorOptions);
+    /**
+     * 完整检测（同时获取支付能力和 Token 信息）
+     * 优先从缓存读取，缓存未命中时执行检测并缓存结果
+     *
+     * @param tokenAddress - Token 地址
+     * @returns 完整的检测结果
+     */
+    detect(tokenAddress: string): Promise<TokenDetectionResult>;
+    /**
+     * 获取推荐的支付方式
+     * 优先级：eip3009 > permit > permit2
+     *
+     * @param tokenAddress - Token 地址
+     * @returns 推荐的支付方式
+     */
+    getRecommendedMethod(tokenAddress: string): Promise<"eip3009" | "permit" | "permit2" | null>;
+    /**
+     * 批量初始化（预热缓存）
+     * 并行检测多个 Token 并缓存结果
+     *
+     * @param tokenAddresses - Token 地址列表
+     * @returns 检测结果数组
+     */
+    initialize(tokenAddresses: string[]): Promise<TokenDetectionResult[]>;
+    /**
+     * 清除缓存
+     *
+     * @param tokenAddress - 可选，指定要清除的 Token 地址
+     */
+    clearCache(tokenAddress?: string): Promise<void>;
+    /**
+     * 获取缓存统计
+     *
+     * @returns 缓存统计信息
+     */
+    getCacheStats(): {
+        size: number;
+        keys: string[];
+    };
+    /**
+     * 生成缓存键
+     *
+     * @param tokenAddress - Token 地址
+     * @returns 缓存键
+     */
+    private getCacheKey;
+}
+
+export { EIP1822_IMPLEMENTATION_SLOT, EIP1967_IMPLEMENTATION_SLOT, EIP2612_PERMIT, EIP3009_SIGNATURES, type Logger, PERMIT2_ADDRESS, PRESET_TOKEN_CAPABILITIES, type PaymentMethod, type PresetTokenConfig, type TokenDetectionResult, TokenDetector, type TokenDetectorOptions, type TokenInfo, type TokenPaymentCapabilities, detectTokenPaymentMethods, getImplementationAddress, getRecommendedPaymentMethod, getTokenInfo };

package/dist/esm/index.mjs

@@ -0,0 +1,453 @@
+// src/constants.ts
+var EIP3009_SIGNATURES = ["0xe3ee160e", "0xcf092995"];
+var EIP2612_PERMIT = "0xd505accf";
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var EIP1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+var EIP1822_IMPLEMENTATION_SLOT = "0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3";
+var PRESET_TOKEN_CAPABILITIES = {
+  // World Liberty Financial USD - 只支持 permit
+  "0x8d0d000ee44948fc98c9b98a4fa4921476f08b0d": {
+    supportedMethods: ["permit"],
+    supportedNetworks: [56],
+    // BSC
+    description: "World Liberty Financial USD (WLFI)"
+  }
+  // 可以继续添加更多预设代币
+  // 示例：
+  // "0x其他代币地址": {
+  //   supportedMethods: ["eip3009", "permit"],
+  //   supportedNetworks: [1, 56],
+  //   description: "代币名称",
+  // },
+};
+
+// src/proxy.ts
+var defaultLogger = {
+  log: (message) => console.log(message),
+  error: (message, error) => console.error(message, error)
+};
+async function getImplementationAddress(client, proxyAddress, logger = defaultLogger) {
+  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") {
+          logger == null ? void 0 : logger.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") {
+          logger == null ? void 0 : logger.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") {
+        logger == null ? void 0 : logger.log(`  \u{1F4E6} Detected proxy via implementation(), implementation: ${implAddress}`);
+        return implAddress;
+      }
+    } catch {
+    }
+    return null;
+  } catch (error) {
+    logger == null ? void 0 : logger.error("Error detecting proxy implementation:", error);
+    return null;
+  }
+}
+
+// src/detector.ts
+var defaultLogger2 = {
+  log: (message) => console.log(message),
+  error: (message, error) => console.error(message, error)
+};
+async function hasMethod(client, tokenAddress, methodSelector, logger = defaultLogger2) {
+  try {
+    const code = await client.getCode({ 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, logger);
+    if (implAddress) {
+      const implCode = await client.getCode({ address: implAddress });
+      if (implCode) {
+        const hasMethodInImpl = implCode.toLowerCase().includes(methodSelector.slice(2).toLowerCase());
+        if (hasMethodInImpl) {
+          logger == null ? void 0 : logger.log(`  \u2705 Method ${methodSelector} found in implementation contract`);
+        }
+        return hasMethodInImpl;
+      }
+    }
+    return false;
+  } catch (error) {
+    logger == null ? void 0 : logger.error(`Error checking method ${methodSelector}:`, error);
+    return false;
+  }
+}
+async function hasAnyMethod(client, tokenAddress, methodSelectors, logger = defaultLogger2) {
+  try {
+    const code = await client.getCode({ 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, logger);
+    if (implAddress) {
+      const implCode = await client.getCode({ address: implAddress });
+      if (implCode) {
+        const implCodeLower = implCode.toLowerCase();
+        const hasMethodInImpl = methodSelectors.some(
+          (selector) => implCodeLower.includes(selector.slice(2).toLowerCase())
+        );
+        if (hasMethodInImpl) {
+          logger == null ? void 0 : logger.log(`  \u2705 Method(s) found in implementation contract`);
+        }
+        return hasMethodInImpl;
+      }
+    }
+    return false;
+  } catch (error) {
+    logger == null ? void 0 : logger.error(`Error checking methods ${methodSelectors.join(", ")}:`, error);
+    return false;
+  }
+}
+async function checkPermit2Support(client, logger = defaultLogger2) {
+  try {
+    const permit2Code = await client.getCode({ address: PERMIT2_ADDRESS });
+    if (!permit2Code) return false;
+    return true;
+  } catch (error) {
+    logger == null ? void 0 : logger.error("Error checking Permit2 support:", error);
+    return false;
+  }
+}
+async function detectTokenPaymentMethods(tokenAddress, client, logger = defaultLogger2) {
+  const address = tokenAddress.toLowerCase();
+  const chainId = await client.getChainId();
+  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) {
+      logger == null ? void 0 : logger.log("  \u2705 EIP-3009 (transferWithAuthorization) - from preset");
+    }
+    if (hasPermit2) {
+      logger == null ? void 0 : logger.log("  \u2705 EIP-2612 (permit) - from preset");
+    }
+    if (hasPermit2Approval2) {
+      logger == null ? void 0 : logger.log("  \u2705 Permit2 support - from preset");
+    }
+    return {
+      address,
+      supportedMethods: presetCapabilities.supportedMethods,
+      details: {
+        hasEIP3009: hasEIP30092,
+        hasPermit: hasPermit2,
+        hasPermit2Approval: hasPermit2Approval2
+      }
+    };
+  }
+  logger == null ? void 0 : logger.log(`\u{1F50D} Detecting payment methods for token ${address}...`);
+  const [hasEIP3009, hasPermit, hasPermit2Approval] = await Promise.all([
+    hasAnyMethod(client, address, EIP3009_SIGNATURES, logger),
+    hasMethod(client, address, EIP2612_PERMIT, logger),
+    checkPermit2Support(client, logger)
+  ]);
+  const supportedMethods = [];
+  if (hasEIP3009) {
+    supportedMethods.push("eip3009");
+    logger == null ? void 0 : logger.log("  \u2705 EIP-3009 (transferWithAuthorization) detected");
+  }
+  if (hasPermit) {
+    supportedMethods.push("permit");
+    logger == null ? void 0 : logger.log("  \u2705 EIP-2612 (permit) detected");
+  }
+  if (hasPermit2Approval) {
+    supportedMethods.push("permit2");
+    supportedMethods.push("permit2-witness");
+    logger == null ? void 0 : logger.log("  \u2705 Permit2 support available (universal)");
+  }
+  if (supportedMethods.length === 0) {
+    logger == null ? void 0 : logger.log("  \u26A0\uFE0F  No advanced payment methods detected (standard ERC-20 only)");
+  }
+  return {
+    address,
+    supportedMethods,
+    details: {
+      hasEIP3009,
+      hasPermit,
+      hasPermit2Approval
+    }
+  };
+}
+async function getRecommendedPaymentMethod(tokenAddress, client, logger = defaultLogger2) {
+  const capabilities = await detectTokenPaymentMethods(tokenAddress, client, logger);
+  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, logger = defaultLogger2) {
+  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, logger);
+    if (implAddress) {
+      logger == null ? void 0 : logger.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 {
+        logger == null ? void 0 : logger.log(`  \u2139\uFE0F  Using default version "1" for token ${address}`);
+      }
+    }
+    return {
+      name,
+      version
+    };
+  } catch (error) {
+    logger == null ? void 0 : logger.error(`Error getting token info for ${address}:`, error);
+    throw new Error(`Failed to get token info: ${error}`);
+  }
+}
+
+// src/cache.ts
+var defaultLogger3 = {
+  log: (message) => console.log(message),
+  error: (message, error) => console.error(message, error)
+};
+var TokenDetector = class {
+  /**
+   * 构造函数
+   *
+   * @param client - viem PublicClient
+   * @param options - 可选配置
+   */
+  constructor(client, options) {
+    /** 缓存存储 (chainId:address -> TokenDetectionResult) */
+    this.cache = /* @__PURE__ */ new Map();
+    this.client = client;
+    this.logger = (options == null ? void 0 : options.logger) === null ? null : (options == null ? void 0 : options.logger) || defaultLogger3;
+  }
+  /**
+   * 完整检测（同时获取支付能力和 Token 信息）
+   * 优先从缓存读取，缓存未命中时执行检测并缓存结果
+   *
+   * @param tokenAddress - Token 地址
+   * @returns 完整的检测结果
+   */
+  async detect(tokenAddress) {
+    var _a, _b;
+    const cacheKey = await this.getCacheKey(tokenAddress);
+    const cached = this.cache.get(cacheKey);
+    if (cached) {
+      (_a = this.logger) == null ? void 0 : _a.log(`\u{1F4BE} Using cached result for token ${tokenAddress}`);
+      return cached;
+    }
+    (_b = this.logger) == null ? void 0 : _b.log(`\u{1F50D} Detecting token ${tokenAddress}...`);
+    const [capabilities, info] = await Promise.all([
+      detectTokenPaymentMethods(tokenAddress, this.client, this.logger),
+      getTokenInfo(tokenAddress, this.client, this.logger)
+    ]);
+    const result = {
+      ...capabilities,
+      ...info
+    };
+    this.cache.set(cacheKey, result);
+    return result;
+  }
+  /**
+   * 获取推荐的支付方式
+   * 优先级：eip3009 > permit > permit2
+   *
+   * @param tokenAddress - Token 地址
+   * @returns 推荐的支付方式
+   */
+  async getRecommendedMethod(tokenAddress) {
+    const result = await this.detect(tokenAddress);
+    const { supportedMethods } = result;
+    if (supportedMethods.includes("eip3009")) return "eip3009";
+    if (supportedMethods.includes("permit")) return "permit";
+    if (supportedMethods.includes("permit2") || supportedMethods.includes("permit2-witness")) {
+      return "permit2";
+    }
+    return null;
+  }
+  /**
+   * 批量初始化（预热缓存）
+   * 并行检测多个 Token 并缓存结果
+   *
+   * @param tokenAddresses - Token 地址列表
+   * @returns 检测结果数组
+   */
+  async initialize(tokenAddresses) {
+    var _a, _b;
+    (_a = this.logger) == null ? void 0 : _a.log(`\u{1F525} Warming up cache for ${tokenAddresses.length} tokens...`);
+    const results = await Promise.all(
+      tokenAddresses.map(
+        (address) => this.detect(address).catch((error) => {
+          var _a2;
+          (_a2 = this.logger) == null ? void 0 : _a2.error(`Failed to detect token ${address}:`, error);
+          return null;
+        })
+      )
+    );
+    const successCount = results.filter((r) => r !== null).length;
+    (_b = this.logger) == null ? void 0 : _b.log(`\u2705 Successfully detected ${successCount}/${tokenAddresses.length} tokens`);
+    return results.filter((r) => r !== null);
+  }
+  /**
+   * 清除缓存
+   *
+   * @param tokenAddress - 可选，指定要清除的 Token 地址
+   */
+  async clearCache(tokenAddress) {
+    var _a, _b;
+    if (tokenAddress) {
+      const cacheKey = await this.getCacheKey(tokenAddress);
+      this.cache.delete(cacheKey);
+      (_a = this.logger) == null ? void 0 : _a.log(`\u{1F5D1}\uFE0F  Cleared cache for token ${tokenAddress}`);
+    } else {
+      this.cache.clear();
+      (_b = this.logger) == null ? void 0 : _b.log(`\u{1F5D1}\uFE0F  Cleared all cache`);
+    }
+  }
+  /**
+   * 获取缓存统计
+   *
+   * @returns 缓存统计信息
+   */
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      keys: Array.from(this.cache.keys())
+    };
+  }
+  /**
+   * 生成缓存键
+   *
+   * @param tokenAddress - Token 地址
+   * @returns 缓存键
+   */
+  async getCacheKey(tokenAddress) {
+    const chainId = await this.client.getChainId();
+    return `${chainId}:${tokenAddress.toLowerCase()}`;
+  }
+};
+export {
+  EIP1822_IMPLEMENTATION_SLOT,
+  EIP1967_IMPLEMENTATION_SLOT,
+  EIP2612_PERMIT,
+  EIP3009_SIGNATURES,
+  PERMIT2_ADDRESS,
+  PRESET_TOKEN_CAPABILITIES,
+  TokenDetector,
+  detectTokenPaymentMethods,
+  getImplementationAddress,
+  getRecommendedPaymentMethod,
+  getTokenInfo
+};
+//# sourceMappingURL=index.mjs.map