@t402/evm 2.2.0 → 2.3.0

package/dist/cjs/upto/index.js

@@ -0,0 +1,1030 @@
+"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/upto/index.ts
+var upto_exports = {};
+__export(upto_exports, {
+  UptoEvmFacilitatorScheme: () => UptoEvmFacilitatorScheme,
+  UptoEvmScheme: () => UptoEvmScheme,
+  UptoEvmServerScheme: () => UptoEvmServerScheme,
+  createUptoEvmFacilitatorScheme: () => createUptoEvmFacilitatorScheme,
+  createUptoEvmScheme: () => createUptoEvmScheme,
+  createUptoEvmServerScheme: () => createUptoEvmServerScheme,
+  isUptoEIP2612Payload: () => isUptoEIP2612Payload,
+  permitTypes: () => permitTypes
+});
+module.exports = __toCommonJS(upto_exports);
+
+// src/upto/client/scheme.ts
+var import_viem2 = require("viem");
+
+// src/types.ts
+var permitTypes = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+function isUptoEIP2612Payload(payload) {
+  if (typeof payload !== "object" || payload === null) return false;
+  const p = payload;
+  return "signature" in p && "authorization" in p && "paymentNonce" in p && typeof p.authorization === "object" && p.authorization !== null && "owner" in p.authorization && "spender" in p.authorization && "value" in p.authorization && "deadline" in p.authorization && "nonce" in p.authorization;
+}
+
+// src/utils.ts
+var import_viem = require("viem");
+function createNonce() {
+  const cryptoObj = typeof globalThis.crypto !== "undefined" ? globalThis.crypto : globalThis.crypto;
+  if (!cryptoObj) {
+    throw new Error("Crypto API not available");
+  }
+  return (0, import_viem.toHex)(cryptoObj.getRandomValues(new Uint8Array(32)));
+}
+
+// src/upto/client/scheme.ts
+var UptoEvmScheme = class {
+  /**
+   * Creates a new UptoEvmScheme instance.
+   *
+   * @param signer - The EVM signer for client operations
+   */
+  constructor(signer) {
+    this.signer = signer;
+    __publicField(this, "scheme", "upto");
+  }
+  /**
+   * Creates a payment payload for the Up-To scheme.
+   *
+   * The payload contains an EIP-2612 permit signature authorizing
+   * the router contract (or facilitator) to transfer up to the
+   * specified maximum amount.
+   *
+   * @param t402Version - The t402 protocol version
+   * @param paymentRequirements - The payment requirements (must include maxAmount)
+   * @returns Promise resolving to a payment payload
+   */
+  async createPaymentPayload(t402Version, paymentRequirements) {
+    if (paymentRequirements.scheme !== "upto") {
+      throw new Error(`Expected upto scheme, got ${paymentRequirements.scheme}`);
+    }
+    const extra = paymentRequirements.extra;
+    if (!extra?.name || !extra?.version) {
+      throw new Error("EIP-712 domain parameters (name, version) are required for upto scheme");
+    }
+    const maxAmount = paymentRequirements.maxAmount;
+    if (!maxAmount) {
+      throw new Error("maxAmount is required for upto scheme");
+    }
+    const spender = extra.routerAddress ? (0, import_viem2.getAddress)(extra.routerAddress) : (0, import_viem2.getAddress)(paymentRequirements.payTo);
+    const now = Math.floor(Date.now() / 1e3);
+    const deadline = now + paymentRequirements.maxTimeoutSeconds;
+    const permitNonce = extra.permitNonce ?? 0;
+    const authorization = {
+      owner: this.signer.address,
+      spender,
+      value: maxAmount,
+      deadline: deadline.toString(),
+      nonce: permitNonce
+    };
+    const signature = await this.signPermit(authorization, paymentRequirements);
+    const paymentNonce = createNonce();
+    const payload = {
+      signature,
+      authorization,
+      paymentNonce
+    };
+    return {
+      t402Version,
+      payload
+    };
+  }
+  /**
+   * Sign the EIP-2612 permit using EIP-712
+   *
+   * @param authorization - The permit authorization to sign
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to the signature components
+   */
+  async signPermit(authorization, requirements) {
+    const chainId = parseInt(requirements.network.split(":")[1]);
+    const extra = requirements.extra;
+    const domain = {
+      name: extra.name,
+      version: extra.version,
+      chainId,
+      verifyingContract: (0, import_viem2.getAddress)(requirements.asset)
+    };
+    const message = {
+      owner: (0, import_viem2.getAddress)(authorization.owner),
+      spender: (0, import_viem2.getAddress)(authorization.spender),
+      value: BigInt(authorization.value),
+      nonce: BigInt(authorization.nonce),
+      deadline: BigInt(authorization.deadline)
+    };
+    const signature = await this.signer.signTypedData({
+      domain,
+      types: permitTypes,
+      primaryType: "Permit",
+      message
+    });
+    const r = `0x${signature.slice(2, 66)}`;
+    const s = `0x${signature.slice(66, 130)}`;
+    const v = parseInt(signature.slice(130, 132), 16);
+    return { v, r, s };
+  }
+};
+function createUptoEvmScheme(signer) {
+  return new UptoEvmScheme(signer);
+}
+
+// src/upto/server/scheme.ts
+var import_types2 = require("@t402/core/types");
+
+// 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 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
+    },
+    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];
+}
+function getTokenByAddress(network, address) {
+  const tokens = TOKEN_REGISTRY[network];
+  if (!tokens) return void 0;
+  const lowerAddress = address.toLowerCase();
+  return Object.values(tokens).find((t) => t.address.toLowerCase() === lowerAddress);
+}
+
+// src/upto/server/scheme.ts
+var UptoEvmServerScheme = class {
+  /**
+   * Creates a new UptoEvmServerScheme instance.
+   *
+   * @param config - Optional configuration options for the scheme
+   */
+  constructor(config = {}) {
+    __publicField(this, "scheme", "upto");
+    __publicField(this, "moneyParsers", []);
+    __publicField(this, "config");
+    this.config = config;
+  }
+  /**
+   * Get all supported networks
+   *
+   * @returns Array of network identifiers in CAIP-2 format
+   */
+  static getSupportedNetworks() {
+    return Object.keys(TOKEN_REGISTRY);
+  }
+  /**
+   * Check if a network is supported
+   *
+   * @param network - The network identifier to check
+   * @returns True if the network is supported
+   */
+  static isNetworkSupported(network) {
+    return network in TOKEN_REGISTRY;
+  }
+  /**
+   * Register a custom money parser in the parser chain.
+   *
+   * @param parser - Custom function to convert amount to AssetAmount
+   * @returns The server instance for chaining
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Parses a price into an asset amount for maxAmount.
+   *
+   * @param price - The price to parse (represents maxAmount)
+   * @param network - The network to use
+   * @returns Promise resolving to the parsed asset amount
+   */
+  async parsePrice(price, network) {
+    if (typeof price === "object" && price !== null && "amount" in price) {
+      if (!price.asset) {
+        const token2 = this.getPreferredToken(network);
+        return { amount: price.amount, asset: token2.address };
+      }
+      return price;
+    }
+    const decimalAmount = this.parseToDecimal(price);
+    for (const parser of this.moneyParsers) {
+      const result = await parser(decimalAmount, network);
+      if (result !== null) {
+        return result;
+      }
+    }
+    const token = this.getPreferredToken(network);
+    const amount = Math.floor(decimalAmount * 10 ** token.decimals).toString();
+    return {
+      amount,
+      asset: token.address
+    };
+  }
+  /**
+   * Enhance payment requirements for the upto scheme.
+   *
+   * @param paymentRequirements - Base payment requirements
+   * @param supportedKind - The supported kind from facilitator
+   * @param supportedKind.t402Version - T402 protocol version
+   * @param supportedKind.scheme - Payment scheme
+   * @param supportedKind.network - Network identifier
+   * @param supportedKind.extra - Extra configuration
+   * @param facilitatorExtensions - Extensions supported by the facilitator
+   * @returns Enhanced payment requirements for upto scheme
+   */
+  async enhancePaymentRequirements(paymentRequirements, supportedKind, facilitatorExtensions) {
+    void facilitatorExtensions;
+    const network = supportedKind.network;
+    const token = getTokenByAddress(network, paymentRequirements.asset);
+    if (!token) {
+      throw new Error(`Unknown token ${paymentRequirements.asset} on ${network}`);
+    }
+    const extra = {
+      // EIP-712 domain (required for permit signing)
+      name: token.name,
+      version: token.version,
+      // Router address (optional - if set, permits go to router)
+      ...this.config.routerAddress && { routerAddress: this.config.routerAddress },
+      // Billing unit info (optional)
+      ...this.config.defaultUnit && { unit: this.config.defaultUnit },
+      ...this.config.defaultUnitPrice && { unitPrice: this.config.defaultUnitPrice },
+      // Upto-specific fields
+      maxAmount: paymentRequirements.amount,
+      minAmount: import_types2.UPTO_DEFAULTS.MIN_AMOUNT,
+      // Merge any facilitator extra
+      ...supportedKind.extra
+    };
+    return {
+      ...paymentRequirements,
+      scheme: "upto",
+      extra
+    };
+  }
+  /**
+   * Get the preferred token for a network.
+   *
+   * @param network - The network identifier
+   * @returns Token configuration
+   * @throws Error if no token is found for the network
+   */
+  getPreferredToken(network) {
+    if (this.config.preferredToken) {
+      const token = getTokenConfig(network, this.config.preferredToken);
+      if (token) return token;
+    }
+    const defaultToken = getDefaultToken(network);
+    if (!defaultToken) {
+      throw new Error(`No token configured for network ${network}`);
+    }
+    return defaultToken;
+  }
+  /**
+   * Parse price to decimal value.
+   *
+   * @param price - Price string or number
+   * @returns Decimal amount
+   */
+  parseToDecimal(price) {
+    if (typeof price === "number") {
+      return price;
+    }
+    const cleaned = price.replace(/[$,]/g, "").trim();
+    const parsed = parseFloat(cleaned);
+    if (isNaN(parsed)) {
+      throw new Error(`Invalid price format: ${price}`);
+    }
+    return parsed;
+  }
+};
+function createUptoEvmServerScheme(config) {
+  return new UptoEvmServerScheme(config);
+}
+
+// src/upto/facilitator/scheme.ts
+var import_viem3 = require("viem");
+var T402_UPTO_ROUTER_ABI = (0, import_viem3.parseAbi)([
+  "function executeUptoTransfer(address token, address from, address to, uint256 maxAmount, uint256 settleAmount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external",
+  "function isFacilitator(address facilitator) external view returns (bool)",
+  "function checkPermitValidity(address token, address from, uint256 maxAmount) external view returns (bool valid, uint256 balance)"
+]);
+var UptoEvmFacilitatorScheme = class {
+  /**
+   * Creates a new UptoEvmFacilitatorScheme instance.
+   *
+   * @param signer - The EVM signer for facilitator operations
+   * @param config - Optional configuration
+   */
+  constructor(signer, config) {
+    this.signer = signer;
+    __publicField(this, "scheme", "upto");
+    __publicField(this, "caipFamily", "eip155:*");
+    __publicField(this, "config");
+    this.config = config ?? {};
+  }
+  /**
+   * Get mechanism-specific extra data for the supported kinds endpoint.
+   *
+   * @param network - The network identifier
+   * @returns Extra data including router address if configured
+   */
+  getExtra(network) {
+    const routerAddress = this.config.routerAddresses?.[network];
+    if (routerAddress) {
+      return { routerAddress };
+    }
+    return void 0;
+  }
+  /**
+   * Get signer addresses used by this facilitator.
+   *
+   * @param _ - The network identifier (unused for EVM)
+   * @returns Array of facilitator wallet addresses
+   */
+  getSigners(_) {
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verifies an upto payment payload.
+   *
+   * @param payload - The payment payload to verify
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to verification response
+   */
+  async verify(payload, requirements) {
+    const uptoPayload = payload.payload;
+    if (!uptoPayload || !isUptoEIP2612Payload(uptoPayload)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_payload_structure",
+        payer: void 0
+      };
+    }
+    if (payload.accepted.scheme !== "upto" || requirements.scheme !== "upto") {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_scheme",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    if (!requirements.extra?.name || !requirements.extra?.version) {
+      return {
+        isValid: false,
+        invalidReason: "missing_eip712_domain",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    const maxAmount = requirements.extra?.maxAmount;
+    if (!maxAmount) {
+      return {
+        isValid: false,
+        invalidReason: "missing_maxAmount",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    if (payload.accepted.network !== requirements.network) {
+      return {
+        isValid: false,
+        invalidReason: "network_mismatch",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    const deadline = parseInt(uptoPayload.authorization.deadline);
+    const now = Math.floor(Date.now() / 1e3);
+    if (deadline <= now) {
+      return {
+        isValid: false,
+        invalidReason: "permit_expired",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    if (uptoPayload.authorization.value !== maxAmount) {
+      return {
+        isValid: false,
+        invalidReason: "amount_mismatch",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    const chainId = parseInt(requirements.network.split(":")[1]);
+    const permitTypedData = {
+      types: permitTypes,
+      primaryType: "Permit",
+      domain: {
+        name: requirements.extra.name,
+        version: requirements.extra.version,
+        chainId,
+        verifyingContract: (0, import_viem3.getAddress)(requirements.asset)
+      },
+      message: {
+        owner: (0, import_viem3.getAddress)(uptoPayload.authorization.owner),
+        spender: (0, import_viem3.getAddress)(uptoPayload.authorization.spender),
+        value: BigInt(uptoPayload.authorization.value),
+        nonce: BigInt(uptoPayload.authorization.nonce),
+        deadline: BigInt(uptoPayload.authorization.deadline)
+      }
+    };
+    const signature = `0x${uptoPayload.signature.r.slice(2)}${uptoPayload.signature.s.slice(2)}${uptoPayload.signature.v.toString(16).padStart(2, "0")}`;
+    try {
+      const isValid = await this.signer.verifyTypedData({
+        address: uptoPayload.authorization.owner,
+        ...permitTypedData,
+        signature
+      });
+      if (!isValid) {
+        return {
+          isValid: false,
+          invalidReason: "invalid_signature",
+          payer: uptoPayload.authorization.owner
+        };
+      }
+    } catch (error) {
+      return {
+        isValid: false,
+        invalidReason: `signature_verification_failed: ${error instanceof Error ? error.message : "unknown"}`,
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    return {
+      isValid: true,
+      payer: uptoPayload.authorization.owner
+    };
+  }
+  /**
+   * Settles an upto payment by calling the T402UptoRouter contract.
+   *
+   * @param payload - The verified payment payload
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to settlement response
+   */
+  async settle(payload, requirements) {
+    const uptoPayload = payload.payload;
+    const maxAmount = requirements.extra?.maxAmount;
+    const minAmount = requirements.extra?.minAmount;
+    const routerAddress = requirements.extra?.routerAddress;
+    if (!maxAmount) {
+      return {
+        success: false,
+        errorReason: "maxAmount not found in payment requirements",
+        transaction: "",
+        network: requirements.network,
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    const settleAmount = maxAmount;
+    if (minAmount && BigInt(settleAmount) < BigInt(minAmount)) {
+      return {
+        success: false,
+        errorReason: `Settle amount ${settleAmount} below minimum ${minAmount}`,
+        transaction: "",
+        network: requirements.network,
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    if (!routerAddress) {
+      return {
+        success: false,
+        errorReason: "Router address not configured",
+        transaction: "",
+        network: requirements.network,
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    try {
+      const txHash = await this.signer.sendTransaction({
+        to: (0, import_viem3.getAddress)(routerAddress),
+        data: (0, import_viem3.encodeFunctionData)({
+          abi: T402_UPTO_ROUTER_ABI,
+          functionName: "executeUptoTransfer",
+          args: [
+            (0, import_viem3.getAddress)(requirements.asset),
+            (0, import_viem3.getAddress)(uptoPayload.authorization.owner),
+            (0, import_viem3.getAddress)(requirements.payTo),
+            BigInt(maxAmount),
+            BigInt(settleAmount),
+            BigInt(uptoPayload.authorization.deadline),
+            uptoPayload.signature.v,
+            uptoPayload.signature.r,
+            uptoPayload.signature.s
+          ]
+        })
+      });
+      const receipt = await this.signer.waitForTransactionReceipt({ hash: txHash });
+      if (receipt.status !== "success") {
+        return {
+          success: false,
+          errorReason: "transaction_reverted",
+          transaction: txHash,
+          network: requirements.network,
+          payer: uptoPayload.authorization.owner
+        };
+      }
+      return {
+        success: true,
+        transaction: txHash,
+        network: requirements.network,
+        payer: uptoPayload.authorization.owner
+      };
+    } catch (error) {
+      return {
+        success: false,
+        errorReason: `Settlement failed: ${error instanceof Error ? error.message : "unknown"}`,
+        transaction: "",
+        network: requirements.network,
+        payer: uptoPayload.authorization.owner
+      };
+    }
+  }
+};
+function createUptoEvmFacilitatorScheme(signer, config) {
+  return new UptoEvmFacilitatorScheme(signer, config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UptoEvmFacilitatorScheme,
+  UptoEvmScheme,
+  UptoEvmServerScheme,
+  createUptoEvmFacilitatorScheme,
+  createUptoEvmScheme,
+  createUptoEvmServerScheme,
+  isUptoEIP2612Payload,
+  permitTypes
+});
+//# sourceMappingURL=index.js.map