@t402/evm 2.6.1 → 2.7.1

package/dist/cjs/permit2-proxy/index.js

@@ -0,0 +1,1274 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/permit2-proxy/index.ts
+var permit2_proxy_exports = {};
+__export(permit2_proxy_exports, {
+  PERMIT2_ADDRESS: () => PERMIT2_ADDRESS,
+  Permit2ProxyEvmClientScheme: () => Permit2ProxyEvmScheme,
+  Permit2ProxyEvmFacilitatorScheme: () => Permit2ProxyEvmScheme3,
+  Permit2ProxyEvmServerScheme: () => Permit2ProxyEvmScheme2,
+  SCHEME_PERMIT2_PROXY: () => SCHEME_PERMIT2_PROXY,
+  T402_EXACT_PERMIT2_PROXY: () => T402_EXACT_PERMIT2_PROXY,
+  T402_UPTO_PERMIT2_PROXY: () => T402_UPTO_PERMIT2_PROXY,
+  WITNESS_TYPEHASH: () => WITNESS_TYPEHASH,
+  WITNESS_TYPE_STRING: () => WITNESS_TYPE_STRING,
+  permit2ProxyExactABI: () => permit2ProxyExactABI,
+  permit2ProxyUptoABI: () => permit2ProxyUptoABI,
+  permit2WitnessTypes: () => permit2WitnessTypes,
+  registerPermit2ProxyEvmClientScheme: () => registerPermit2ProxyEvmScheme,
+  registerPermit2ProxyEvmFacilitatorScheme: () => registerPermit2ProxyEvmScheme3,
+  registerPermit2ProxyEvmServerScheme: () => registerPermit2ProxyEvmScheme2
+});
+module.exports = __toCommonJS(permit2_proxy_exports);
+
+// src/permit2-proxy/client/scheme.ts
+var import_viem = require("viem");
+
+// src/permit2/constants.ts
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var erc20BalanceABI = [
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/permit2-proxy/constants.ts
+var SCHEME_PERMIT2_PROXY = "permit2-proxy";
+var T402_EXACT_PERMIT2_PROXY = "0x0000000000000000000000000000000000000000";
+var T402_UPTO_PERMIT2_PROXY = "0x0000000000000000000000000000000000000000";
+var WITNESS_TYPEHASH = "0x5e3bbbe812684a9a24e1e1b7fe7c5b763bfb791ee8423aed3b4e1a5a9e25c255";
+var WITNESS_TYPE_STRING = "Witness witness)TokenPermissions(address token,uint256 amount)Witness(address to,address facilitator,uint256 validAfter)";
+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" },
+    { name: "facilitator", type: "address" },
+    { name: "validAfter", type: "uint256" }
+  ]
+};
+var permit2ProxyExactABI = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" }
+            ],
+            name: "permitted",
+            type: "tuple"
+          },
+          { name: "nonce", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ],
+        name: "permit",
+        type: "tuple"
+      },
+      { name: "owner", type: "address" },
+      {
+        components: [
+          { name: "to", type: "address" },
+          { name: "facilitator", type: "address" },
+          { name: "validAfter", type: "uint256" }
+        ],
+        name: "witness",
+        type: "tuple"
+      },
+      { name: "signature", type: "bytes" }
+    ],
+    name: "settle",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { name: "value", type: "uint256" },
+          { name: "deadline", type: "uint256" },
+          { name: "v", type: "uint8" },
+          { name: "r", type: "bytes32" },
+          { name: "s", type: "bytes32" }
+        ],
+        name: "permit2612",
+        type: "tuple"
+      },
+      {
+        components: [
+          {
+            components: [
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" }
+            ],
+            name: "permitted",
+            type: "tuple"
+          },
+          { name: "nonce", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ],
+        name: "permit",
+        type: "tuple"
+      },
+      { name: "owner", type: "address" },
+      {
+        components: [
+          { name: "to", type: "address" },
+          { name: "facilitator", type: "address" },
+          { name: "validAfter", type: "uint256" }
+        ],
+        name: "witness",
+        type: "tuple"
+      },
+      { name: "signature", type: "bytes" }
+    ],
+    name: "settleWithPermit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var permit2ProxyUptoABI = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" }
+            ],
+            name: "permitted",
+            type: "tuple"
+          },
+          { name: "nonce", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ],
+        name: "permit",
+        type: "tuple"
+      },
+      { name: "amount", type: "uint256" },
+      { name: "owner", type: "address" },
+      {
+        components: [
+          { name: "to", type: "address" },
+          { name: "facilitator", type: "address" },
+          { name: "validAfter", type: "uint256" }
+        ],
+        name: "witness",
+        type: "tuple"
+      },
+      { name: "signature", type: "bytes" }
+    ],
+    name: "settle",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { name: "value", type: "uint256" },
+          { name: "deadline", type: "uint256" },
+          { name: "v", type: "uint8" },
+          { name: "r", type: "bytes32" },
+          { name: "s", type: "bytes32" }
+        ],
+        name: "permit2612",
+        type: "tuple"
+      },
+      {
+        components: [
+          {
+            components: [
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" }
+            ],
+            name: "permitted",
+            type: "tuple"
+          },
+          { name: "nonce", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ],
+        name: "permit",
+        type: "tuple"
+      },
+      { name: "amount", type: "uint256" },
+      { name: "owner", type: "address" },
+      {
+        components: [
+          { name: "to", type: "address" },
+          { name: "facilitator", type: "address" },
+          { name: "validAfter", type: "uint256" }
+        ],
+        name: "witness",
+        type: "tuple"
+      },
+      { name: "signature", type: "bytes" }
+    ],
+    name: "settleWithPermit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/permit2-proxy/client/scheme.ts
+var Permit2ProxyEvmScheme = class {
+  /**
+   * Creates a new Permit2ProxyEvmScheme instance.
+   *
+   * @param signer - The EVM signer for client operations
+   */
+  constructor(signer) {
+    this.signer = signer;
+    __publicField(this, "scheme", SCHEME_PERMIT2_PROXY);
+  }
+  /**
+   * Creates a payment payload for the Permit2 Proxy scheme.
+   *
+   * @param t402Version - The t402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @returns Promise resolving to a payment payload
+   */
+  async createPaymentPayload(t402Version, paymentRequirements) {
+    const now = Math.floor(Date.now() / 1e3);
+    const deadline = now + paymentRequirements.maxTimeoutSeconds;
+    const nonce = BigInt(
+      "0x" + Array.from(globalThis.crypto.getRandomValues(new Uint8Array(32))).map((b) => b.toString(16).padStart(2, "0")).join("")
+    ).toString();
+    const proxyAddress = paymentRequirements.extra?.exactProxyAddress || paymentRequirements.extra?.uptoProxyAddress;
+    if (!proxyAddress) {
+      throw new Error(
+        "Missing proxy address in payment requirements extra (exactProxyAddress or uptoProxyAddress)"
+      );
+    }
+    const facilitatorAddress = paymentRequirements.extra?.facilitator;
+    if (!facilitatorAddress) {
+      throw new Error("Missing facilitator address in payment requirements extra");
+    }
+    const permit = {
+      permitted: {
+        token: (0, import_viem.getAddress)(paymentRequirements.asset),
+        amount: paymentRequirements.amount
+      },
+      nonce,
+      deadline: deadline.toString()
+    };
+    const witness = {
+      to: (0, import_viem.getAddress)(paymentRequirements.payTo),
+      facilitator: (0, import_viem.getAddress)(facilitatorAddress),
+      validAfter: "0"
+      // Immediate validity
+    };
+    const signature = await this.signPermit2Witness(
+      permit,
+      witness,
+      proxyAddress,
+      paymentRequirements
+    );
+    const payload = {
+      permit,
+      witness,
+      signature,
+      owner: this.signer.address
+    };
+    return {
+      t402Version,
+      payload
+    };
+  }
+  /**
+   * Sign the Permit2 PermitWitnessTransferFrom using EIP-712.
+   *
+   * @param permit - The permit transfer data
+   * @param witness - The witness data
+   * @param spender - The proxy contract address (spender in Permit2)
+   * @param requirements - The payment requirements
+   * @returns Signed typed data hex string
+   */
+  async signPermit2Witness(permit, witness, spender, requirements) {
+    const chainId = parseInt(requirements.network.split(":")[1]);
+    const domain = {
+      name: "Permit2",
+      chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    };
+    const message = {
+      permitted: {
+        token: permit.permitted.token,
+        amount: BigInt(permit.permitted.amount)
+      },
+      spender: (0, import_viem.getAddress)(spender),
+      nonce: BigInt(permit.nonce),
+      deadline: BigInt(permit.deadline),
+      witness: {
+        to: witness.to,
+        facilitator: witness.facilitator,
+        validAfter: BigInt(witness.validAfter)
+      }
+    };
+    return await this.signer.signTypedData({
+      domain,
+      types: permit2WitnessTypes,
+      primaryType: "PermitWitnessTransferFrom",
+      message
+    });
+  }
+};
+
+// src/permit2-proxy/client/register.ts
+function registerPermit2ProxyEvmScheme(client, config) {
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      client.register(network, new Permit2ProxyEvmScheme(config.signer));
+    });
+  } else {
+    client.register("eip155:*", new Permit2ProxyEvmScheme(config.signer));
+  }
+  if (config.policies) {
+    config.policies.forEach((policy) => {
+      client.registerPolicy(policy);
+    });
+  }
+  return client;
+}
+
+// src/tokens.ts
+var USDT0_ADDRESSES = {
+  // === Existing Networks ===
+  // Ethereum Mainnet - OFT Adapter (bridge endpoint)
+  "eip155:1": "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee",
+  // Arbitrum One - Native USDT0
+  "eip155:42161": "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+  // Ink Mainnet
+  "eip155:57073": "0x0200C29006150606B650577BBE7B6248F58470c1",
+  // Berachain Mainnet
+  "eip155:80094": "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+  // Unichain Mainnet (updated address)
+  "eip155:130": "0x9151434b16b9763660705744891fA906F660EcC5",
+  // === Phase 1: High Priority Networks ===
+  // Polygon PoS
+  "eip155:137": "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+  // Mantle
+  "eip155:5000": "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+  // Optimism
+  "eip155:10": "0x01bFF41798a0BcF287b996046Ca68b395DbC1071",
+  // Plasma
+  "eip155:9745": "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+  // Sei
+  "eip155:1329": "0x9151434b16b9763660705744891fA906F660EcC5",
+  // Conflux eSpace
+  "eip155:1030": "0xaf37E8B6C9ED7f6318979f56Fc287d76c30847ff",
+  // Monad
+  "eip155:143": "0xe7cd86e13AC4309349F30B3435a9d337750fC82D",
+  // === Phase 2: Medium Priority Networks ===
+  // Rootstock (Bitcoin sidechain)
+  "eip155:30": "0x779dED0C9e1022225F8e0630b35A9B54Be713736",
+  // XLayer (OKX L2)
+  "eip155:196": "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+  // Flare
+  "eip155:14": "0xe7cd86e13AC4309349F30B3435a9d337750fC82D",
+  // Corn
+  "eip155:21000000": "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+  // HyperEVM
+  "eip155:999": "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+  // MegaETH
+  "eip155:4326": "0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb",
+  // Stable
+  "eip155:988": "0x779Ded0c9e1022225f8E0630b35a9b54bE713736"
+};
+var USDC_ADDRESSES = {
+  // Ethereum Mainnet
+  "eip155:1": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  // Base Mainnet
+  "eip155:8453": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  // Base Sepolia (testnet)
+  "eip155:84532": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  // Sepolia (testnet)
+  "eip155:11155111": "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+  // Arbitrum One
+  "eip155:42161": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  // Polygon Mainnet
+  "eip155:137": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
+};
+var USAT_ADDRESSES = {
+  // Ethereum Mainnet
+  "eip155:1": "0x07041776f5007aca2a54844f50503a18a72a8b68"
+};
+var USDT_LEGACY_ADDRESSES = {
+  // Ethereum Mainnet
+  "eip155:1": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+  // Polygon Mainnet (native USDT, not USDT0)
+  "eip155:137": "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+  // BNB Chain (BSC) - BEP-20 USDT
+  "eip155:56": "0x55d398326f99059fF775485246999027B3197955",
+  // Avalanche C-Chain
+  "eip155:43114": "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+  // Fantom
+  "eip155:250": "0x049d68029688eabf473097a2fc38ef61633a3c7a",
+  // Celo
+  "eip155:42220": "0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e",
+  // Kaia (formerly Klaytn)
+  "eip155:8217": "0xcee8faf64bb97a73bb51e115aa89c17ffa8dd167"
+};
+var TOKEN_REGISTRY = {
+  // Ethereum Mainnet
+  "eip155:1": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:1"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    },
+    USDC: {
+      address: USDC_ADDRESSES["eip155:1"],
+      symbol: "USDC",
+      name: "USD Coin",
+      version: "2",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 2
+    },
+    USAT: {
+      address: USAT_ADDRESSES["eip155:1"],
+      symbol: "USAT",
+      name: "Tether America USD",
+      version: "1",
+      decimals: 6,
+      tokenType: "legacy",
+      priority: 3
+    },
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:1"],
+      symbol: "USDT",
+      name: "TetherUSD",
+      version: "1",
+      decimals: 6,
+      tokenType: "legacy",
+      priority: 10
+      // Lower priority due to legacy flow
+    }
+  },
+  // Arbitrum One
+  "eip155:42161": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:42161"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    },
+    USDC: {
+      address: USDC_ADDRESSES["eip155:42161"],
+      symbol: "USDC",
+      name: "USD Coin",
+      version: "2",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 2
+    }
+  },
+  // Ink Mainnet
+  "eip155:57073": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:57073"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Berachain Mainnet
+  "eip155:80094": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:80094"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Unichain Mainnet
+  "eip155:130": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:130"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Base Mainnet
+  "eip155:8453": {
+    USDC: {
+      address: USDC_ADDRESSES["eip155:8453"],
+      symbol: "USDC",
+      name: "USD Coin",
+      version: "2",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 2
+    }
+  },
+  // Base Sepolia (testnet)
+  "eip155:84532": {
+    USDC: {
+      address: USDC_ADDRESSES["eip155:84532"],
+      symbol: "USDC",
+      name: "USDC",
+      version: "2",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 2
+    }
+  },
+  // Sepolia (testnet)
+  "eip155:11155111": {
+    USDC: {
+      address: USDC_ADDRESSES["eip155:11155111"],
+      symbol: "USDC",
+      name: "USDC",
+      version: "2",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 2
+    }
+  },
+  // Polygon Mainnet
+  "eip155:137": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:137"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    },
+    USDC: {
+      address: USDC_ADDRESSES["eip155:137"],
+      symbol: "USDC",
+      name: "USD Coin",
+      version: "2",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 2
+    },
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:137"],
+      symbol: "USDT",
+      name: "TetherUSD",
+      version: "1",
+      decimals: 6,
+      tokenType: "legacy",
+      priority: 10
+    }
+  },
+  // === Phase 1: High Priority USDT0 Networks ===
+  // Optimism Mainnet
+  "eip155:10": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:10"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Mantle Mainnet
+  "eip155:5000": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:5000"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Plasma Mainnet
+  "eip155:9745": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:9745"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Sei Mainnet
+  "eip155:1329": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:1329"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Conflux eSpace Mainnet
+  "eip155:1030": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:1030"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Monad Mainnet
+  "eip155:143": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:143"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // === Phase 2: Medium Priority USDT0 Networks ===
+  // Flare Mainnet
+  "eip155:14": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:14"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Rootstock Mainnet (Bitcoin sidechain)
+  "eip155:30": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:30"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // XLayer Mainnet (OKX L2)
+  "eip155:196": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:196"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Stable Mainnet
+  "eip155:988": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:988"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // HyperEVM Mainnet
+  "eip155:999": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:999"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // MegaETH Mainnet
+  "eip155:4326": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:4326"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Corn Mainnet
+  "eip155:21000000": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:21000000"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // === Legacy USDT Networks (no EIP-3009 support) ===
+  // BNB Chain (BSC) - BEP-20 USDT
+  "eip155:56": {
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:56"],
+      symbol: "USDT",
+      name: "Tether USD",
+      version: "1",
+      decimals: 18,
+      // BSC USDT uses 18 decimals
+      tokenType: "legacy",
+      priority: 10
+    }
+  },
+  // Avalanche C-Chain
+  "eip155:43114": {
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:43114"],
+      symbol: "USDT",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "legacy",
+      priority: 10
+    }
+  },
+  // Fantom
+  "eip155:250": {
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:250"],
+      symbol: "USDT",
+      name: "Frapped USDT",
+      version: "1",
+      decimals: 6,
+      tokenType: "legacy",
+      priority: 10
+    }
+  },
+  // Celo
+  "eip155:42220": {
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:42220"],
+      symbol: "USDT",
+      name: "Tether USD",
+      version: "1",
+      decimals: 18,
+      tokenType: "legacy",
+      priority: 10
+    }
+  },
+  // Kaia (formerly Klaytn)
+  "eip155:8217": {
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:8217"],
+      symbol: "USDT",
+      name: "Tether USD",
+      version: "1",
+      decimals: 6,
+      tokenType: "legacy",
+      priority: 10
+    }
+  }
+};
+function getTokenConfig(network, symbol) {
+  return TOKEN_REGISTRY[network]?.[symbol.toUpperCase()];
+}
+function getNetworkTokens(network) {
+  const tokens = TOKEN_REGISTRY[network];
+  if (!tokens) return [];
+  return Object.values(tokens).sort((a, b) => a.priority - b.priority);
+}
+function getDefaultToken(network) {
+  const tokens = getNetworkTokens(network);
+  return tokens[0];
+}
+
+// src/permit2-proxy/server/scheme.ts
+var Permit2ProxyEvmScheme2 = class {
+  /**
+   * Creates a new Permit2ProxyEvmScheme server instance.
+   *
+   * @param config - Server configuration options
+   */
+  constructor(config = {}) {
+    __publicField(this, "scheme", SCHEME_PERMIT2_PROXY);
+    __publicField(this, "moneyParsers", []);
+    __publicField(this, "config");
+    this.config = config;
+  }
+  /**
+   * Get the list of supported EVM networks.
+   *
+   * @returns Array of supported network identifiers
+   */
+  static getSupportedNetworks() {
+    return Object.keys(TOKEN_REGISTRY);
+  }
+  /**
+   * Check if a network is supported.
+   *
+   * @param network - Network identifier to check
+   * @returns Whether the network is supported
+   */
+  static isNetworkSupported(network) {
+    return network in TOKEN_REGISTRY;
+  }
+  /**
+   * Register a custom money parser for price conversion.
+   *
+   * @param parser - The money parser to register
+   * @returns This instance for chaining
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Parse a price into an AssetAmount for the given network.
+   *
+   * @param price - The price to parse
+   * @param network - The target network
+   * @returns The parsed asset amount
+   */
+  async parsePrice(price, network) {
+    if (typeof price === "object" && price !== null && "amount" in price) {
+      if (!price.asset) {
+        throw new Error(`Asset address must be specified for AssetAmount on network ${network}`);
+      }
+      return {
+        amount: price.amount,
+        asset: price.asset,
+        extra: price.extra || {}
+      };
+    }
+    const amount = this.parseMoneyToDecimal(price);
+    for (const parser of this.moneyParsers) {
+      const result = await parser(amount, network);
+      if (result !== null) {
+        return result;
+      }
+    }
+    return this.defaultMoneyConversion(amount, network);
+  }
+  /**
+   * Enhance payment requirements with Permit2 Proxy-specific data.
+   *
+   * @param paymentRequirements - The base payment requirements
+   * @param supportedKind - The supported kind metadata
+   * @param supportedKind.t402Version - Protocol version
+   * @param supportedKind.scheme - Payment scheme
+   * @param supportedKind.network - Target network
+   * @param supportedKind.extra - Extra metadata
+   * @param extensionKeys - Active extension keys
+   * @returns Enhanced payment requirements
+   */
+  enhancePaymentRequirements(paymentRequirements, supportedKind, extensionKeys) {
+    void extensionKeys;
+    if (!paymentRequirements.extra) {
+      paymentRequirements.extra = {};
+    }
+    paymentRequirements.extra.permit2Address = PERMIT2_ADDRESS;
+    paymentRequirements.extra.exactProxyAddress = this.config.exactProxyAddress || T402_EXACT_PERMIT2_PROXY;
+    paymentRequirements.extra.uptoProxyAddress = this.config.uptoProxyAddress || T402_UPTO_PERMIT2_PROXY;
+    if (supportedKind.extra?.facilitator) {
+      paymentRequirements.extra.facilitator = supportedKind.extra.facilitator;
+    }
+    return Promise.resolve(paymentRequirements);
+  }
+  /**
+   * Parse a money value into a decimal number.
+   *
+   * @param money - The money value to parse
+   * @returns The decimal amount
+   */
+  parseMoneyToDecimal(money) {
+    if (typeof money === "number") {
+      if (!Number.isFinite(money)) {
+        throw new Error(`Invalid money value: ${money} (must be a finite number)`);
+      }
+      return money;
+    }
+    const cleanMoney = money.replace(/^\$/, "").trim();
+    const amount = parseFloat(cleanMoney);
+    if (!Number.isFinite(amount)) {
+      throw new Error(`Invalid money format: ${money}`);
+    }
+    return amount;
+  }
+  /**
+   * Convert a decimal amount to a token amount using default network token.
+   *
+   * @param amount - The decimal amount
+   * @param network - The target network
+   * @returns The asset amount with token details
+   */
+  defaultMoneyConversion(amount, network) {
+    const token = this.getDefaultAsset(network);
+    const tokenAmount = this.convertToTokenAmount(amount.toString(), token.decimals);
+    return {
+      amount: tokenAmount,
+      asset: token.address,
+      extra: {
+        symbol: token.symbol,
+        permit2Address: PERMIT2_ADDRESS
+      }
+    };
+  }
+  /**
+   * Convert a decimal amount string to token smallest units.
+   *
+   * @param decimalAmount - The decimal amount as a string
+   * @param decimals - The token's decimal places
+   * @returns The amount in smallest units
+   */
+  convertToTokenAmount(decimalAmount, decimals) {
+    if (!/^-?\d+(\.\d+)?$/.test(decimalAmount)) {
+      throw new Error(`Invalid amount format: ${decimalAmount}`);
+    }
+    const [wholePart, fracPart = ""] = decimalAmount.split(".");
+    const paddedFrac = fracPart.padEnd(decimals, "0").slice(0, decimals);
+    const combined = wholePart + paddedFrac;
+    const result = combined.replace(/^0+/, "") || "0";
+    return result;
+  }
+  /**
+   * Get the default token asset for a network.
+   *
+   * @param network - The target network
+   * @returns The token configuration
+   */
+  getDefaultAsset(network) {
+    if (this.config.preferredToken) {
+      const preferred = getTokenConfig(network, this.config.preferredToken);
+      if (preferred) return preferred;
+    }
+    const defaultToken = getDefaultToken(network);
+    if (defaultToken) return defaultToken;
+    throw new Error(`No tokens configured for network ${network}`);
+  }
+};
+
+// src/permit2-proxy/server/register.ts
+function registerPermit2ProxyEvmScheme2(server, config = {}) {
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      server.register(network, new Permit2ProxyEvmScheme2(config.schemeConfig));
+    });
+  } else {
+    server.register("eip155:*", new Permit2ProxyEvmScheme2(config.schemeConfig));
+  }
+  return server;
+}
+
+// src/permit2-proxy/facilitator/scheme.ts
+var import_viem2 = require("viem");
+var Permit2ProxyEvmScheme3 = class {
+  /**
+   * Creates a new Permit2 Proxy facilitator instance.
+   *
+   * @param signer - The facilitator EVM signer
+   * @param config - Optional configuration
+   */
+  constructor(signer, config = {}) {
+    this.signer = signer;
+    __publicField(this, "scheme", SCHEME_PERMIT2_PROXY);
+    __publicField(this, "caipFamily", "eip155:*");
+    __publicField(this, "exactProxyAddress");
+    __publicField(this, "uptoProxyAddress");
+    this.exactProxyAddress = config.exactProxyAddress || T402_EXACT_PERMIT2_PROXY;
+    this.uptoProxyAddress = config.uptoProxyAddress || T402_UPTO_PERMIT2_PROXY;
+  }
+  /**
+   * Get mechanism-specific extra data for supported kinds.
+   *
+   * @param _ - The network identifier
+   * @returns Extra data including proxy contract addresses
+   */
+  getExtra(_) {
+    return {
+      permit2Address: PERMIT2_ADDRESS,
+      exactProxyAddress: this.exactProxyAddress,
+      uptoProxyAddress: this.uptoProxyAddress
+    };
+  }
+  /**
+   * Get signer addresses for this facilitator.
+   *
+   * @param _ - The network identifier
+   * @returns Array of signer addresses
+   */
+  getSigners(_) {
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verify a Permit2 Proxy payment payload.
+   *
+   * @param payload - The payment payload to verify
+   * @param requirements - The payment requirements
+   * @returns Verification result
+   */
+  async verify(payload, requirements) {
+    const proxyPayload = payload.payload;
+    if (!proxyPayload?.permit?.permitted?.token || !proxyPayload?.owner || !proxyPayload?.witness) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_payload_structure",
+        payer: void 0
+      };
+    }
+    if (payload.accepted.scheme !== SCHEME_PERMIT2_PROXY || requirements.scheme !== SCHEME_PERMIT2_PROXY) {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_scheme",
+        payer: proxyPayload.owner
+      };
+    }
+    if (payload.accepted.network !== requirements.network) {
+      return {
+        isValid: false,
+        invalidReason: "network_mismatch",
+        payer: proxyPayload.owner
+      };
+    }
+    if ((0, import_viem2.getAddress)(proxyPayload.permit.permitted.token) !== (0, import_viem2.getAddress)(requirements.asset)) {
+      return {
+        isValid: false,
+        invalidReason: "token_mismatch",
+        payer: proxyPayload.owner
+      };
+    }
+    if ((0, import_viem2.getAddress)(proxyPayload.witness.to) !== (0, import_viem2.getAddress)(requirements.payTo)) {
+      return {
+        isValid: false,
+        invalidReason: "recipient_mismatch",
+        payer: proxyPayload.owner
+      };
+    }
+    const signerAddresses = this.signer.getAddresses().map((a) => (0, import_viem2.getAddress)(a));
+    if (!signerAddresses.includes((0, import_viem2.getAddress)(proxyPayload.witness.facilitator))) {
+      return {
+        isValid: false,
+        invalidReason: "facilitator_mismatch",
+        payer: proxyPayload.owner
+      };
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (BigInt(proxyPayload.permit.deadline) < BigInt(now + 6)) {
+      return {
+        isValid: false,
+        invalidReason: "permit_expired",
+        payer: proxyPayload.owner
+      };
+    }
+    if (BigInt(proxyPayload.witness.validAfter) > BigInt(now)) {
+      return {
+        isValid: false,
+        invalidReason: "payment_too_early",
+        payer: proxyPayload.owner
+      };
+    }
+    if (BigInt(proxyPayload.permit.permitted.amount) < BigInt(requirements.amount)) {
+      return {
+        isValid: false,
+        invalidReason: "insufficient_permitted_amount",
+        payer: proxyPayload.owner
+      };
+    }
+    try {
+      const balance = await this.signer.readContract({
+        address: (0, import_viem2.getAddress)(requirements.asset),
+        abi: erc20BalanceABI,
+        functionName: "balanceOf",
+        args: [(0, import_viem2.getAddress)(proxyPayload.owner)]
+      });
+      if (BigInt(balance) < BigInt(requirements.amount)) {
+        return {
+          isValid: false,
+          invalidReason: "insufficient_funds",
+          payer: proxyPayload.owner
+        };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        isValid: false,
+        invalidReason: `balance_check_failed: ${errorMessage}`,
+        payer: proxyPayload.owner
+      };
+    }
+    return {
+      isValid: true,
+      invalidReason: void 0,
+      payer: proxyPayload.owner
+    };
+  }
+  /**
+   * Settle a Permit2 Proxy payment by calling settle() on the proxy contract.
+   *
+   * @param payload - The payment payload
+   * @param requirements - The payment requirements
+   * @returns Settlement result
+   */
+  async settle(payload, requirements) {
+    const proxyPayload = payload.payload;
+    if (!proxyPayload?.permit?.permitted?.token || !proxyPayload?.owner || !proxyPayload?.witness) {
+      return {
+        success: false,
+        network: payload.accepted.network,
+        transaction: "",
+        errorReason: "invalid_payload_structure",
+        payer: void 0
+      };
+    }
+    const valid = await this.verify(payload, requirements);
+    if (!valid.isValid) {
+      return {
+        success: false,
+        network: payload.accepted.network,
+        transaction: "",
+        errorReason: valid.invalidReason ?? "invalid_scheme",
+        payer: proxyPayload.owner
+      };
+    }
+    try {
+      const proxyAddress = requirements.extra?.exactProxyAddress || this.exactProxyAddress;
+      const tx = await this.signer.writeContract({
+        address: proxyAddress,
+        abi: permit2ProxyExactABI,
+        functionName: "settle",
+        args: [
+          {
+            permitted: {
+              token: (0, import_viem2.getAddress)(proxyPayload.permit.permitted.token),
+              amount: BigInt(proxyPayload.permit.permitted.amount)
+            },
+            nonce: BigInt(proxyPayload.permit.nonce),
+            deadline: BigInt(proxyPayload.permit.deadline)
+          },
+          (0, import_viem2.getAddress)(proxyPayload.owner),
+          {
+            to: (0, import_viem2.getAddress)(proxyPayload.witness.to),
+            facilitator: (0, import_viem2.getAddress)(proxyPayload.witness.facilitator),
+            validAfter: BigInt(proxyPayload.witness.validAfter)
+          },
+          proxyPayload.signature
+        ]
+      });
+      const receipt = await this.signer.waitForTransactionReceipt({ hash: tx });
+      if (receipt.status !== "success") {
+        return {
+          success: false,
+          errorReason: "invalid_transaction_state",
+          transaction: tx,
+          network: payload.accepted.network,
+          payer: proxyPayload.owner
+        };
+      }
+      return {
+        success: true,
+        transaction: tx,
+        network: payload.accepted.network,
+        payer: proxyPayload.owner
+      };
+    } catch (error) {
+      console.error("Failed to settle Permit2 Proxy transaction:", error);
+      return {
+        success: false,
+        errorReason: "transaction_failed",
+        transaction: "",
+        network: payload.accepted.network,
+        payer: proxyPayload.owner
+      };
+    }
+  }
+};
+
+// src/permit2-proxy/facilitator/register.ts
+function registerPermit2ProxyEvmScheme3(facilitator, config) {
+  facilitator.register(
+    config.networks,
+    new Permit2ProxyEvmScheme3(config.signer, config.schemeConfig)
+  );
+  return facilitator;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PERMIT2_ADDRESS,
+  Permit2ProxyEvmClientScheme,
+  Permit2ProxyEvmFacilitatorScheme,
+  Permit2ProxyEvmServerScheme,
+  SCHEME_PERMIT2_PROXY,
+  T402_EXACT_PERMIT2_PROXY,
+  T402_UPTO_PERMIT2_PROXY,
+  WITNESS_TYPEHASH,
+  WITNESS_TYPE_STRING,
+  permit2ProxyExactABI,
+  permit2ProxyUptoABI,
+  permit2WitnessTypes,
+  registerPermit2ProxyEvmClientScheme,
+  registerPermit2ProxyEvmFacilitatorScheme,
+  registerPermit2ProxyEvmServerScheme
+});
+//# sourceMappingURL=index.js.map