@t402/evm 2.0.0

package/dist/esm/index.mjs

@@ -0,0 +1,1875 @@
+import {
+  ExactEvmScheme
+} from "./chunk-LGSG73NJ.mjs";
+import {
+  TOKEN_PRIORITY,
+  TOKEN_REGISTRY,
+  USDC_ADDRESSES,
+  USDT0_ADDRESSES,
+  USDT_LEGACY_ADDRESSES,
+  getDefaultToken,
+  getEIP712Domain,
+  getNetworkTokens,
+  getNetworksForToken,
+  getTokenByAddress,
+  getTokenConfig,
+  getUsdt0Networks,
+  supportsEIP3009
+} from "./chunk-OEXW2OK2.mjs";
+import {
+  authorizationTypes,
+  createNonce,
+  eip3009ABI,
+  erc20LegacyABI,
+  legacyAuthorizationTypes
+} from "./chunk-XYKAO6KJ.mjs";
+
+// src/exact-legacy/client/scheme.ts
+import { getAddress } from "viem";
+var ExactLegacyEvmScheme = class {
+  /**
+   * Creates a new ExactLegacyEvmScheme instance.
+   *
+   * @param signer - The EVM signer for client operations
+   */
+  constructor(signer) {
+    this.signer = signer;
+    this.scheme = "exact-legacy";
+  }
+  /**
+   * Creates a payment payload for the exact-legacy scheme.
+   *
+   * @param t402Version - The t402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @returns Promise resolving to a payment payload
+   */
+  async createPaymentPayload(t402Version, paymentRequirements) {
+    if (!paymentRequirements.extra?.spender) {
+      throw new Error(
+        "exact-legacy scheme requires 'spender' (facilitator address) in payment requirements extra field"
+      );
+    }
+    const spender = getAddress(paymentRequirements.extra.spender);
+    const nonce = createNonce();
+    const now = Math.floor(Date.now() / 1e3);
+    const authorization = {
+      from: this.signer.address,
+      to: getAddress(paymentRequirements.payTo),
+      value: paymentRequirements.amount,
+      validAfter: (now - 600).toString(),
+      // 10 minutes before
+      validBefore: (now + paymentRequirements.maxTimeoutSeconds).toString(),
+      nonce,
+      spender
+    };
+    const signature = await this.signAuthorization(authorization, paymentRequirements);
+    const payload = {
+      authorization,
+      signature
+    };
+    return {
+      t402Version,
+      payload
+    };
+  }
+  /**
+   * Sign the legacy transfer authorization using EIP-712
+   *
+   * @param authorization - The authorization to sign
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to the signature
+   */
+  async signAuthorization(authorization, requirements) {
+    const chainId = parseInt(requirements.network.split(":")[1]);
+    const name = requirements.extra?.name || "T402LegacyTransfer";
+    const version = requirements.extra?.version || "1";
+    const domain = {
+      name,
+      version,
+      chainId,
+      verifyingContract: getAddress(requirements.asset)
+    };
+    const message = {
+      from: getAddress(authorization.from),
+      to: getAddress(authorization.to),
+      value: BigInt(authorization.value),
+      validAfter: BigInt(authorization.validAfter),
+      validBefore: BigInt(authorization.validBefore),
+      nonce: authorization.nonce,
+      spender: getAddress(authorization.spender)
+    };
+    return await this.signer.signTypedData({
+      domain,
+      types: legacyAuthorizationTypes,
+      primaryType: "LegacyTransferAuthorization",
+      message
+    });
+  }
+};
+
+// src/exact-legacy/server/scheme.ts
+var ExactLegacyEvmScheme2 = class {
+  constructor(config = {}) {
+    this.scheme = "exact-legacy";
+    this.moneyParsers = [];
+    this.config = config;
+  }
+  /**
+   * Register a custom money parser in the parser chain.
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Parses a price into an asset amount for legacy tokens.
+   */
+  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,
+          tokenType: "legacy"
+        }
+      };
+    }
+    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);
+  }
+  /**
+   * Build payment requirements for this scheme/network combination.
+   * Adds the spender (facilitator) address to the extra field.
+   */
+  enhancePaymentRequirements(paymentRequirements, supportedKind, extensionKeys) {
+    void extensionKeys;
+    const spender = supportedKind.extra?.spender;
+    return Promise.resolve({
+      ...paymentRequirements,
+      extra: {
+        ...paymentRequirements.extra,
+        tokenType: "legacy",
+        ...spender && { spender }
+      }
+    });
+  }
+  /**
+   * Parse Money (string | number) to a decimal number.
+   */
+  parseMoneyToDecimal(money) {
+    if (typeof money === "number") {
+      return money;
+    }
+    const cleanMoney = money.replace(/^\$/, "").trim();
+    const amount = parseFloat(cleanMoney);
+    if (isNaN(amount)) {
+      throw new Error(`Invalid money format: ${money}`);
+    }
+    return amount;
+  }
+  /**
+   * Default money conversion implementation for legacy tokens.
+   */
+  defaultMoneyConversion(amount, network) {
+    const token = this.getDefaultAsset(network);
+    const tokenAmount = this.convertToTokenAmount(amount.toString(), token.decimals);
+    return {
+      amount: tokenAmount,
+      asset: token.address,
+      extra: {
+        name: token.name,
+        version: token.version,
+        symbol: token.symbol,
+        tokenType: "legacy"
+      }
+    };
+  }
+  /**
+   * Convert decimal amount to token units
+   */
+  convertToTokenAmount(decimalAmount, decimals) {
+    const amount = parseFloat(decimalAmount);
+    if (isNaN(amount)) {
+      throw new Error(`Invalid amount: ${decimalAmount}`);
+    }
+    const tokenAmount = Math.floor(amount * Math.pow(10, decimals));
+    return tokenAmount.toString();
+  }
+  /**
+   * Get the default legacy token for a network.
+   */
+  getDefaultAsset(network) {
+    if (this.config.preferredToken) {
+      const preferred = getTokenConfig(network, this.config.preferredToken);
+      if (preferred && preferred.tokenType === "legacy") {
+        return preferred;
+      }
+    }
+    const usdt = getTokenConfig(network, "USDT");
+    if (usdt && usdt.tokenType === "legacy") {
+      return usdt;
+    }
+    const tokens = TOKEN_REGISTRY[network];
+    if (tokens) {
+      const legacyToken = Object.values(tokens).find((t) => t.tokenType === "legacy");
+      if (legacyToken) return legacyToken;
+    }
+    throw new Error(`No legacy tokens configured for network ${network}`);
+  }
+  /**
+   * Get all supported networks that have legacy tokens
+   */
+  static getSupportedNetworks() {
+    return Object.keys(USDT_LEGACY_ADDRESSES);
+  }
+  /**
+   * Check if a network has legacy token support
+   */
+  static isNetworkSupported(network) {
+    return network in USDT_LEGACY_ADDRESSES;
+  }
+};
+
+// src/exact-legacy/facilitator/scheme.ts
+import { getAddress as getAddress2, isAddressEqual } from "viem";
+var ExactLegacyEvmScheme3 = class {
+  /**
+   * Creates a new ExactLegacyEvmScheme instance.
+   *
+   * @param signer - The EVM signer for facilitator operations
+   * @param config - Optional configuration
+   */
+  constructor(signer, config) {
+    this.signer = signer;
+    this.scheme = "exact-legacy";
+    this.caipFamily = "eip155:*";
+    this.config = {
+      minAllowanceRatio: config?.minAllowanceRatio ?? 1
+    };
+  }
+  /**
+   * Get mechanism-specific extra data for the supported kinds endpoint.
+   * For exact-legacy, returns the spender (facilitator) addresses.
+   *
+   * @param network - The network identifier
+   * @returns Extra data including spender addresses
+   */
+  getExtra(network) {
+    void network;
+    const addresses = this.signer.getAddresses();
+    if (addresses.length > 0) {
+      return {
+        spender: addresses[0],
+        tokenType: "legacy"
+      };
+    }
+    return { tokenType: "legacy" };
+  }
+  /**
+   * Get signer addresses used by this facilitator.
+   */
+  getSigners(network) {
+    void network;
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verifies a payment payload.
+   */
+  async verify(payload, requirements) {
+    const legacyPayload = payload.payload;
+    if (payload.accepted.scheme !== "exact-legacy" || requirements.scheme !== "exact-legacy") {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_scheme",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    if (payload.accepted.network !== requirements.network) {
+      return {
+        isValid: false,
+        invalidReason: "network_mismatch",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    const erc20Address = getAddress2(requirements.asset);
+    const spender = getAddress2(legacyPayload.authorization.spender);
+    const facilitatorAddresses = this.signer.getAddresses();
+    const isValidSpender = facilitatorAddresses.some((addr) => isAddressEqual(addr, spender));
+    if (!isValidSpender) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_spender",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    const name = requirements.extra?.name || "T402LegacyTransfer";
+    const version = requirements.extra?.version || "1";
+    const chainId = parseInt(requirements.network.split(":")[1]);
+    const domain = {
+      name,
+      version,
+      chainId,
+      verifyingContract: erc20Address
+    };
+    const message = {
+      from: legacyPayload.authorization.from,
+      to: legacyPayload.authorization.to,
+      value: BigInt(legacyPayload.authorization.value),
+      validAfter: BigInt(legacyPayload.authorization.validAfter),
+      validBefore: BigInt(legacyPayload.authorization.validBefore),
+      nonce: legacyPayload.authorization.nonce,
+      spender: legacyPayload.authorization.spender
+    };
+    try {
+      const isValid = await this.signer.verifyTypedData({
+        address: legacyPayload.authorization.from,
+        domain,
+        types: legacyAuthorizationTypes,
+        primaryType: "LegacyTransferAuthorization",
+        message,
+        signature: legacyPayload.signature
+      });
+      if (!isValid) {
+        return {
+          isValid: false,
+          invalidReason: "invalid_signature",
+          payer: legacyPayload.authorization.from
+        };
+      }
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: "signature_verification_failed",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    if (getAddress2(legacyPayload.authorization.to) !== getAddress2(requirements.payTo)) {
+      return {
+        isValid: false,
+        invalidReason: "recipient_mismatch",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (BigInt(legacyPayload.authorization.validBefore) < BigInt(now + 6)) {
+      return {
+        isValid: false,
+        invalidReason: "authorization_expired",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    if (BigInt(legacyPayload.authorization.validAfter) > BigInt(now)) {
+      return {
+        isValid: false,
+        invalidReason: "authorization_not_yet_valid",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    try {
+      const balance = await this.signer.readContract({
+        address: erc20Address,
+        abi: erc20LegacyABI,
+        functionName: "balanceOf",
+        args: [legacyPayload.authorization.from]
+      });
+      if (BigInt(balance) < BigInt(requirements.amount)) {
+        return {
+          isValid: false,
+          invalidReason: "insufficient_balance",
+          payer: legacyPayload.authorization.from
+        };
+      }
+    } catch {
+    }
+    try {
+      const allowance = await this.signer.readContract({
+        address: erc20Address,
+        abi: erc20LegacyABI,
+        functionName: "allowance",
+        args: [legacyPayload.authorization.from, spender]
+      });
+      const requiredAllowance = BigInt(
+        Math.floor(Number(requirements.amount) * this.config.minAllowanceRatio)
+      );
+      if (allowance < requiredAllowance) {
+        return {
+          isValid: false,
+          invalidReason: "insufficient_allowance",
+          payer: legacyPayload.authorization.from
+        };
+      }
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: "allowance_check_failed",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    if (BigInt(legacyPayload.authorization.value) < BigInt(requirements.amount)) {
+      return {
+        isValid: false,
+        invalidReason: "insufficient_amount",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    return {
+      isValid: true,
+      invalidReason: void 0,
+      payer: legacyPayload.authorization.from
+    };
+  }
+  /**
+   * Settles a payment by executing transferFrom.
+   */
+  async settle(payload, requirements) {
+    const legacyPayload = payload.payload;
+    const valid = await this.verify(payload, requirements);
+    if (!valid.isValid) {
+      return {
+        success: false,
+        network: payload.accepted.network,
+        transaction: "",
+        errorReason: valid.invalidReason ?? "invalid_payment",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    try {
+      const tx = await this.signer.writeContract({
+        address: getAddress2(requirements.asset),
+        abi: erc20LegacyABI,
+        functionName: "transferFrom",
+        args: [
+          getAddress2(legacyPayload.authorization.from),
+          getAddress2(legacyPayload.authorization.to),
+          BigInt(legacyPayload.authorization.value)
+        ]
+      });
+      const receipt = await this.signer.waitForTransactionReceipt({ hash: tx });
+      if (receipt.status !== "success") {
+        return {
+          success: false,
+          errorReason: "transaction_failed",
+          transaction: tx,
+          network: payload.accepted.network,
+          payer: legacyPayload.authorization.from
+        };
+      }
+      return {
+        success: true,
+        transaction: tx,
+        network: payload.accepted.network,
+        payer: legacyPayload.authorization.from
+      };
+    } catch (error) {
+      console.error("Failed to settle legacy transaction:", error);
+      return {
+        success: false,
+        errorReason: "settlement_failed",
+        transaction: "",
+        network: payload.accepted.network,
+        payer: legacyPayload.authorization.from
+      };
+    }
+  }
+};
+
+// src/signer.ts
+function toClientEvmSigner(signer) {
+  return signer;
+}
+function toFacilitatorEvmSigner(client) {
+  return {
+    ...client,
+    getAddresses: () => [client.address]
+  };
+}
+
+// src/bridge/constants.ts
+var LAYERZERO_ENDPOINT_IDS = {
+  // Mainnets
+  ethereum: 30101,
+  arbitrum: 30110,
+  base: 30184,
+  optimism: 30111,
+  polygon: 30109,
+  avalanche: 30106,
+  bsc: 30102,
+  // USDT0 specific chains
+  ink: 30291,
+  // Ink mainnet
+  berachain: 30362,
+  // Berachain mainnet
+  unichain: 30320,
+  // Unichain mainnet
+  // Testnets
+  sepolia: 40161,
+  arbitrumSepolia: 40231,
+  baseSepolia: 40245
+};
+var NETWORK_TO_CHAIN = {
+  "eip155:1": "ethereum",
+  "eip155:42161": "arbitrum",
+  "eip155:8453": "base",
+  "eip155:10": "optimism",
+  "eip155:137": "polygon",
+  "eip155:43114": "avalanche",
+  "eip155:56": "bsc",
+  "eip155:57073": "ink",
+  "eip155:80094": "berachain",
+  "eip155:130": "unichain",
+  // Testnets
+  "eip155:11155111": "sepolia",
+  "eip155:421614": "arbitrumSepolia",
+  "eip155:84532": "baseSepolia"
+};
+var CHAIN_TO_NETWORK = Object.fromEntries(
+  Object.entries(NETWORK_TO_CHAIN).map(([k, v]) => [v, k])
+);
+var USDT0_OFT_ADDRESSES = {
+  // Ethereum is the OFT Adapter (locks/unlocks tokens)
+  ethereum: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee",
+  // Other chains have native USDT0 OFT contracts
+  arbitrum: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+  ink: "0x0200C29006150606B650577BBE7B6248F58470c1",
+  berachain: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+  unichain: "0x588ce4F028D8e7B53B687865d6A67b3A54C75518"
+};
+var LAYERZERO_ENDPOINT_V2 = "0x1a44076050125825900e736c501f859c50fE728c";
+var DEFAULT_EXTRA_OPTIONS = "0x00030100110100000000000000000000000000030d40";
+var OFT_SEND_ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          { name: "dstEid", type: "uint32" },
+          { name: "to", type: "bytes32" },
+          { name: "amountLD", type: "uint256" },
+          { name: "minAmountLD", type: "uint256" },
+          { name: "extraOptions", type: "bytes" },
+          { name: "composeMsg", type: "bytes" },
+          { name: "oftCmd", type: "bytes" }
+        ],
+        name: "_sendParam",
+        type: "tuple"
+      },
+      {
+        components: [
+          { name: "nativeFee", type: "uint256" },
+          { name: "lzTokenFee", type: "uint256" }
+        ],
+        name: "_fee",
+        type: "tuple"
+      },
+      { name: "_refundAddress", type: "address" }
+    ],
+    name: "send",
+    outputs: [
+      {
+        components: [
+          { name: "guid", type: "bytes32" },
+          { name: "nonce", type: "uint64" },
+          {
+            components: [
+              { name: "nativeFee", type: "uint256" },
+              { name: "lzTokenFee", type: "uint256" }
+            ],
+            name: "fee",
+            type: "tuple"
+          }
+        ],
+        name: "msgReceipt",
+        type: "tuple"
+      },
+      {
+        components: [
+          { name: "amountSentLD", type: "uint256" },
+          { name: "amountReceivedLD", type: "uint256" }
+        ],
+        name: "oftReceipt",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { name: "dstEid", type: "uint32" },
+          { name: "to", type: "bytes32" },
+          { name: "amountLD", type: "uint256" },
+          { name: "minAmountLD", type: "uint256" },
+          { name: "extraOptions", type: "bytes" },
+          { name: "composeMsg", type: "bytes" },
+          { name: "oftCmd", type: "bytes" }
+        ],
+        name: "_sendParam",
+        type: "tuple"
+      },
+      { name: "_payInLzToken", type: "bool" }
+    ],
+    name: "quoteSend",
+    outputs: [
+      {
+        components: [
+          { name: "nativeFee", type: "uint256" },
+          { name: "lzTokenFee", type: "uint256" }
+        ],
+        name: "msgFee",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var ERC20_APPROVE_ABI = [
+  {
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    name: "allowance",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+function getEndpointId(chain) {
+  return LAYERZERO_ENDPOINT_IDS[chain];
+}
+function getUsdt0OftAddress(chain) {
+  return USDT0_OFT_ADDRESSES[chain];
+}
+function supportsBridging(chain) {
+  return chain in USDT0_OFT_ADDRESSES && chain in LAYERZERO_ENDPOINT_IDS;
+}
+function getBridgeableChains() {
+  return Object.keys(USDT0_OFT_ADDRESSES).filter(
+    (chain) => chain in LAYERZERO_ENDPOINT_IDS
+  );
+}
+function addressToBytes32(address) {
+  const cleanAddress = address.slice(2).toLowerCase();
+  return `0x${cleanAddress.padStart(64, "0")}`;
+}
+function bytes32ToAddress(bytes32) {
+  return `0x${bytes32.slice(-40)}`;
+}
+
+// src/bridge/client.ts
+var DEFAULT_SLIPPAGE = 0.5;
+var ESTIMATED_BRIDGE_TIME = 300;
+var Usdt0Bridge = class {
+  /**
+   * Create a new bridge client
+   *
+   * @param signer - Wallet signer with read/write capabilities
+   * @param chain - Source chain name (e.g., "arbitrum", "ethereum")
+   */
+  constructor(signer, chain) {
+    if (!supportsBridging(chain)) {
+      throw new Error(
+        `Chain "${chain}" does not support USDT0 bridging. Supported chains: ${getBridgeableChains().join(", ")}`
+      );
+    }
+    this.signer = signer;
+    this.chain = chain;
+  }
+  /**
+   * Get a quote for bridging USDT0
+   *
+   * @param params - Bridge parameters
+   * @returns Quote with fee and amount information
+   */
+  async quote(params) {
+    this.validateBridgeParams(params);
+    const sendParam = this.buildSendParam(params);
+    const oftAddress = getUsdt0OftAddress(params.fromChain);
+    const fee = await this.signer.readContract({
+      address: oftAddress,
+      abi: OFT_SEND_ABI,
+      functionName: "quoteSend",
+      args: [sendParam, false]
+    });
+    return {
+      nativeFee: fee.nativeFee,
+      amountToSend: params.amount,
+      minAmountToReceive: sendParam.minAmountLD,
+      estimatedTime: ESTIMATED_BRIDGE_TIME,
+      fromChain: params.fromChain,
+      toChain: params.toChain
+    };
+  }
+  /**
+   * Execute a bridge transaction
+   *
+   * @param params - Bridge execution parameters
+   * @returns Bridge result with transaction hash
+   */
+  async send(params) {
+    this.validateBridgeParams(params);
+    const oftAddress = getUsdt0OftAddress(params.fromChain);
+    const sendParam = this.buildSendParam(params);
+    const refundAddress = params.refundAddress ?? this.signer.address;
+    const fee = await this.signer.readContract({
+      address: oftAddress,
+      abi: OFT_SEND_ABI,
+      functionName: "quoteSend",
+      args: [sendParam, false]
+    });
+    await this.ensureAllowance(oftAddress, params.amount);
+    const txHash = await this.signer.writeContract({
+      address: oftAddress,
+      abi: OFT_SEND_ABI,
+      functionName: "send",
+      args: [sendParam, fee, refundAddress],
+      value: fee.nativeFee
+    });
+    const receipt = await this.signer.waitForTransactionReceipt({ hash: txHash });
+    if (receipt.status !== "success") {
+      throw new Error(`Bridge transaction failed: ${txHash}`);
+    }
+    return {
+      txHash,
+      messageGuid: "0x" + "0".repeat(64),
+      // Would be extracted from event logs
+      amountSent: params.amount,
+      amountToReceive: sendParam.minAmountLD,
+      fromChain: params.fromChain,
+      toChain: params.toChain,
+      estimatedTime: ESTIMATED_BRIDGE_TIME
+    };
+  }
+  /**
+   * Ensure sufficient token allowance for the OFT contract
+   */
+  async ensureAllowance(oftAddress, amount) {
+    const allowance = await this.signer.readContract({
+      address: oftAddress,
+      abi: ERC20_APPROVE_ABI,
+      functionName: "allowance",
+      args: [this.signer.address, oftAddress]
+    });
+    if (allowance < amount) {
+      const approveTx = await this.signer.writeContract({
+        address: oftAddress,
+        abi: ERC20_APPROVE_ABI,
+        functionName: "approve",
+        args: [oftAddress, amount]
+      });
+      await this.signer.waitForTransactionReceipt({ hash: approveTx });
+    }
+  }
+  /**
+   * Build SendParam struct for LayerZero
+   */
+  buildSendParam(params) {
+    const dstEid = getEndpointId(params.toChain);
+    if (!dstEid) {
+      throw new Error(`Unknown destination chain: ${params.toChain}`);
+    }
+    const slippage = "slippageTolerance" in params ? params.slippageTolerance ?? DEFAULT_SLIPPAGE : DEFAULT_SLIPPAGE;
+    const minAmount = params.amount - params.amount * BigInt(Math.floor(slippage * 100)) / 10000n;
+    return {
+      dstEid,
+      to: addressToBytes32(params.recipient),
+      amountLD: params.amount,
+      minAmountLD: minAmount,
+      extraOptions: DEFAULT_EXTRA_OPTIONS,
+      composeMsg: "0x",
+      oftCmd: "0x"
+    };
+  }
+  /**
+   * Validate bridge parameters
+   */
+  validateBridgeParams(params) {
+    if (params.fromChain !== this.chain) {
+      throw new Error(
+        `Source chain mismatch: bridge initialized for "${this.chain}" but got "${params.fromChain}"`
+      );
+    }
+    if (!supportsBridging(params.fromChain)) {
+      throw new Error(`Source chain "${params.fromChain}" does not support USDT0 bridging`);
+    }
+    if (!supportsBridging(params.toChain)) {
+      throw new Error(`Destination chain "${params.toChain}" does not support USDT0 bridging`);
+    }
+    if (params.fromChain === params.toChain) {
+      throw new Error("Source and destination chains must be different");
+    }
+    if (params.amount <= 0n) {
+      throw new Error("Amount must be greater than 0");
+    }
+  }
+  /**
+   * Get all supported destination chains from current chain
+   */
+  getSupportedDestinations() {
+    return getBridgeableChains().filter((chain) => chain !== this.chain);
+  }
+  /**
+   * Check if a destination chain is supported
+   */
+  supportsDestination(toChain) {
+    return toChain !== this.chain && supportsBridging(toChain);
+  }
+};
+function createUsdt0Bridge(signer, chain) {
+  return new Usdt0Bridge(signer, chain);
+}
+
+// src/erc4337/constants.ts
+var ENTRYPOINT_V07_ADDRESS = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+var ENTRYPOINT_V06_ADDRESS = "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";
+var DEFAULT_GAS_LIMITS = {
+  /** Gas for account validation */
+  verificationGasLimit: 150000n,
+  /** Gas for callData execution */
+  callGasLimit: 100000n,
+  /** Gas paid to bundler for overhead */
+  preVerificationGas: 50000n,
+  /** Gas for paymaster validation */
+  paymasterVerificationGasLimit: 50000n,
+  /** Gas for paymaster post-op */
+  paymasterPostOpGasLimit: 50000n
+};
+var ENTRYPOINT_V07_ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          { name: "sender", type: "address" },
+          { name: "nonce", type: "uint256" },
+          { name: "initCode", type: "bytes" },
+          { name: "callData", type: "bytes" },
+          { name: "accountGasLimits", type: "bytes32" },
+          { name: "preVerificationGas", type: "uint256" },
+          { name: "gasFees", type: "bytes32" },
+          { name: "paymasterAndData", type: "bytes" },
+          { name: "signature", type: "bytes" }
+        ],
+        name: "ops",
+        type: "tuple[]"
+      },
+      { name: "beneficiary", type: "address" }
+    ],
+    name: "handleOps",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "sender", type: "address" }],
+    name: "getNonce",
+    outputs: [{ name: "nonce", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "key", type: "uint192" }
+    ],
+    name: "getNonce",
+    outputs: [{ name: "nonce", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { name: "sender", type: "address" },
+          { name: "nonce", type: "uint256" },
+          { name: "initCode", type: "bytes" },
+          { name: "callData", type: "bytes" },
+          { name: "accountGasLimits", type: "bytes32" },
+          { name: "preVerificationGas", type: "uint256" },
+          { name: "gasFees", type: "bytes32" },
+          { name: "paymasterAndData", type: "bytes" },
+          { name: "signature", type: "bytes" }
+        ],
+        name: "userOp",
+        type: "tuple"
+      }
+    ],
+    name: "getUserOpHash",
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var ACCOUNT_ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          { name: "sender", type: "address" },
+          { name: "nonce", type: "uint256" },
+          { name: "initCode", type: "bytes" },
+          { name: "callData", type: "bytes" },
+          { name: "accountGasLimits", type: "bytes32" },
+          { name: "preVerificationGas", type: "uint256" },
+          { name: "gasFees", type: "bytes32" },
+          { name: "paymasterAndData", type: "bytes" },
+          { name: "signature", type: "bytes" }
+        ],
+        name: "userOp",
+        type: "tuple"
+      },
+      { name: "userOpHash", type: "bytes32" },
+      { name: "missingAccountFunds", type: "uint256" }
+    ],
+    name: "validateUserOp",
+    outputs: [{ name: "validationData", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "dest", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "func", type: "bytes" }
+    ],
+    name: "execute",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "dest", type: "address[]" },
+      { name: "value", type: "uint256[]" },
+      { name: "func", type: "bytes[]" }
+    ],
+    name: "executeBatch",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var BUNDLER_METHODS = {
+  sendUserOperation: "eth_sendUserOperation",
+  estimateUserOperationGas: "eth_estimateUserOperationGas",
+  getUserOperationByHash: "eth_getUserOperationByHash",
+  getUserOperationReceipt: "eth_getUserOperationReceipt",
+  supportedEntryPoints: "eth_supportedEntryPoints",
+  chainId: "eth_chainId"
+};
+var PaymasterType = /* @__PURE__ */ ((PaymasterType2) => {
+  PaymasterType2["None"] = "none";
+  PaymasterType2["Verifying"] = "verifying";
+  PaymasterType2["Token"] = "token";
+  PaymasterType2["Sponsoring"] = "sponsoring";
+  return PaymasterType2;
+})(PaymasterType || {});
+function packAccountGasLimits(verificationGasLimit, callGasLimit) {
+  const verificationHex = verificationGasLimit.toString(16).padStart(32, "0");
+  const callHex = callGasLimit.toString(16).padStart(32, "0");
+  return `0x${verificationHex}${callHex}`;
+}
+function unpackAccountGasLimits(packed) {
+  const hex = packed.slice(2);
+  const verificationHex = hex.slice(0, 32);
+  const callHex = hex.slice(32, 64);
+  return {
+    verificationGasLimit: BigInt("0x" + verificationHex),
+    callGasLimit: BigInt("0x" + callHex)
+  };
+}
+function packGasFees(maxPriorityFeePerGas, maxFeePerGas) {
+  const priorityHex = maxPriorityFeePerGas.toString(16).padStart(32, "0");
+  const maxHex = maxFeePerGas.toString(16).padStart(32, "0");
+  return `0x${priorityHex}${maxHex}`;
+}
+function unpackGasFees(packed) {
+  const hex = packed.slice(2);
+  const priorityHex = hex.slice(0, 32);
+  const maxHex = hex.slice(32, 64);
+  return {
+    maxPriorityFeePerGas: BigInt("0x" + priorityHex),
+    maxFeePerGas: BigInt("0x" + maxHex)
+  };
+}
+
+// src/erc4337/builder.ts
+import { concat, pad, toHex } from "viem";
+var UserOpBuilder = class {
+  constructor(options = {}) {
+    this.entryPoint = options.entryPoint ?? ENTRYPOINT_V07_ADDRESS;
+    this.gasMultiplier = options.gasMultiplier ?? 1.2;
+  }
+  /**
+   * Build a UserOperation from a transaction intent
+   */
+  async buildUserOp(signer, intent, client, gasEstimate, paymaster) {
+    const sender = await signer.getAddress();
+    const nonce = await this.getNonce(client, sender);
+    const isDeployed = await signer.isDeployed();
+    const initCode = isDeployed ? "0x" : await signer.getInitCode();
+    const callData = signer.encodeExecute(
+      intent.to,
+      intent.value ?? 0n,
+      intent.data ?? "0x"
+    );
+    const { maxFeePerGas, maxPriorityFeePerGas } = await this.getGasPrices(client);
+    const gas = gasEstimate ?? DEFAULT_GAS_LIMITS;
+    const verificationGasLimit = this.applyMultiplier(gas.verificationGasLimit);
+    const callGasLimit = this.applyMultiplier(gas.callGasLimit);
+    const preVerificationGas = this.applyMultiplier(gas.preVerificationGas);
+    const paymasterAndData = paymaster ? this.encodePaymasterData(paymaster) : "0x";
+    return {
+      sender,
+      nonce,
+      initCode,
+      callData,
+      verificationGasLimit,
+      callGasLimit,
+      preVerificationGas,
+      maxPriorityFeePerGas,
+      maxFeePerGas,
+      paymasterAndData,
+      signature: "0x"
+      // Will be filled after signing
+    };
+  }
+  /**
+   * Build a batch UserOperation from multiple transaction intents
+   */
+  async buildBatchUserOp(signer, intents, client, gasEstimate, paymaster) {
+    const sender = await signer.getAddress();
+    const nonce = await this.getNonce(client, sender);
+    const isDeployed = await signer.isDeployed();
+    const initCode = isDeployed ? "0x" : await signer.getInitCode();
+    const targets = intents.map((i) => i.to);
+    const values = intents.map((i) => i.value ?? 0n);
+    const datas = intents.map((i) => i.data ?? "0x");
+    const callData = signer.encodeExecuteBatch(targets, values, datas);
+    const { maxFeePerGas, maxPriorityFeePerGas } = await this.getGasPrices(client);
+    const gas = gasEstimate ?? {
+      verificationGasLimit: DEFAULT_GAS_LIMITS.verificationGasLimit,
+      callGasLimit: DEFAULT_GAS_LIMITS.callGasLimit * BigInt(intents.length),
+      preVerificationGas: DEFAULT_GAS_LIMITS.preVerificationGas
+    };
+    const verificationGasLimit = this.applyMultiplier(gas.verificationGasLimit);
+    const callGasLimit = this.applyMultiplier(gas.callGasLimit);
+    const preVerificationGas = this.applyMultiplier(gas.preVerificationGas);
+    const paymasterAndData = paymaster ? this.encodePaymasterData(paymaster) : "0x";
+    return {
+      sender,
+      nonce,
+      initCode,
+      callData,
+      verificationGasLimit,
+      callGasLimit,
+      preVerificationGas,
+      maxPriorityFeePerGas,
+      maxFeePerGas,
+      paymasterAndData,
+      signature: "0x"
+    };
+  }
+  /**
+   * Pack a UserOperation for on-chain submission (v0.7 format)
+   */
+  packUserOp(userOp) {
+    return {
+      sender: userOp.sender,
+      nonce: userOp.nonce,
+      initCode: userOp.initCode,
+      callData: userOp.callData,
+      accountGasLimits: packAccountGasLimits(
+        userOp.verificationGasLimit,
+        userOp.callGasLimit
+      ),
+      preVerificationGas: userOp.preVerificationGas,
+      gasFees: packGasFees(userOp.maxPriorityFeePerGas, userOp.maxFeePerGas),
+      paymasterAndData: userOp.paymasterAndData,
+      signature: userOp.signature
+    };
+  }
+  /**
+   * Compute the UserOperation hash for signing
+   */
+  async getUserOpHash(userOp, client, chainId) {
+    const packed = this.packUserOp(userOp);
+    const userOpTuple = {
+      sender: packed.sender,
+      nonce: packed.nonce,
+      initCode: packed.initCode,
+      callData: packed.callData,
+      accountGasLimits: packed.accountGasLimits,
+      preVerificationGas: packed.preVerificationGas,
+      gasFees: packed.gasFees,
+      paymasterAndData: packed.paymasterAndData,
+      signature: packed.signature
+    };
+    const hash = await client.readContract({
+      address: this.entryPoint,
+      abi: ENTRYPOINT_V07_ABI,
+      functionName: "getUserOpHash",
+      args: [userOpTuple]
+    });
+    return hash;
+  }
+  /**
+   * Sign a UserOperation
+   */
+  async signUserOp(userOp, signer, client, chainId) {
+    const userOpHash = await this.getUserOpHash(userOp, client, chainId);
+    const signature = await signer.signUserOpHash(userOpHash);
+    return {
+      ...userOp,
+      signature
+    };
+  }
+  /**
+   * Get the nonce for an account from EntryPoint
+   */
+  async getNonce(client, sender) {
+    try {
+      const nonce = await client.readContract({
+        address: this.entryPoint,
+        abi: ENTRYPOINT_V07_ABI,
+        functionName: "getNonce",
+        args: [sender, 0n]
+        // Use key 0 for default nonce space
+      });
+      return nonce;
+    } catch {
+      return 0n;
+    }
+  }
+  /**
+   * Get current gas prices from the chain
+   */
+  async getGasPrices(client) {
+    const block = await client.getBlock({ blockTag: "latest" });
+    const baseFee = block.baseFeePerGas ?? 0n;
+    const maxPriorityFeePerGas = 1500000000n;
+    const maxFeePerGas = baseFee * 2n + maxPriorityFeePerGas;
+    return { maxFeePerGas, maxPriorityFeePerGas };
+  }
+  /**
+   * Apply gas multiplier for safety margin
+   */
+  applyMultiplier(gas) {
+    return BigInt(Math.ceil(Number(gas) * this.gasMultiplier));
+  }
+  /**
+   * Encode paymaster data for the UserOperation
+   */
+  encodePaymasterData(paymaster) {
+    const paymasterAddress = paymaster.paymaster;
+    const verificationGas = pad(toHex(paymaster.paymasterVerificationGasLimit), {
+      size: 16
+    });
+    const postOpGas = pad(toHex(paymaster.paymasterPostOpGasLimit), { size: 16 });
+    return concat([
+      paymasterAddress,
+      verificationGas,
+      postOpGas,
+      paymaster.paymasterData
+    ]);
+  }
+};
+function createUserOpBuilder(options) {
+  return new UserOpBuilder(options);
+}
+
+// src/erc4337/bundler.ts
+var BundlerError = class extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "BundlerError";
+  }
+};
+var BundlerClient = class {
+  constructor(config) {
+    this.requestId = 0;
+    this.bundlerUrl = config.bundlerUrl;
+    this.entryPoint = config.entryPoint ?? ENTRYPOINT_V07_ADDRESS;
+    this.chainId = config.chainId;
+  }
+  /**
+   * Send a UserOperation to the bundler
+   */
+  async sendUserOperation(userOp) {
+    const packed = this.packForRpc(userOp);
+    const userOpHash = await this.rpcCall(
+      BUNDLER_METHODS.sendUserOperation,
+      [packed, this.entryPoint]
+    );
+    return {
+      userOpHash,
+      wait: () => this.waitForReceipt(userOpHash)
+    };
+  }
+  /**
+   * Estimate gas for a UserOperation
+   */
+  async estimateUserOperationGas(userOp) {
+    const estimationOp = {
+      sender: userOp.sender,
+      nonce: userOp.nonce ?? 0n,
+      initCode: userOp.initCode ?? "0x",
+      callData: userOp.callData,
+      verificationGasLimit: userOp.verificationGasLimit ?? 1000000n,
+      callGasLimit: userOp.callGasLimit ?? 1000000n,
+      preVerificationGas: userOp.preVerificationGas ?? 100000n,
+      maxPriorityFeePerGas: userOp.maxPriorityFeePerGas ?? 1000000000n,
+      maxFeePerGas: userOp.maxFeePerGas ?? 10000000000n,
+      paymasterAndData: userOp.paymasterAndData ?? "0x",
+      signature: userOp.signature ?? // Dummy signature for estimation
+      "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c"
+    };
+    const packed = this.packForRpc(estimationOp);
+    const result = await this.rpcCall(BUNDLER_METHODS.estimateUserOperationGas, [packed, this.entryPoint]);
+    return {
+      verificationGasLimit: BigInt(result.verificationGasLimit),
+      callGasLimit: BigInt(result.callGasLimit),
+      preVerificationGas: BigInt(result.preVerificationGas),
+      paymasterVerificationGasLimit: result.paymasterVerificationGasLimit ? BigInt(result.paymasterVerificationGasLimit) : void 0,
+      paymasterPostOpGasLimit: result.paymasterPostOpGasLimit ? BigInt(result.paymasterPostOpGasLimit) : void 0
+    };
+  }
+  /**
+   * Get UserOperation by hash
+   */
+  async getUserOperationByHash(userOpHash) {
+    const result = await this.rpcCall(BUNDLER_METHODS.getUserOperationByHash, [userOpHash]);
+    return result;
+  }
+  /**
+   * Get UserOperation receipt
+   */
+  async getUserOperationReceipt(userOpHash) {
+    const result = await this.rpcCall(BUNDLER_METHODS.getUserOperationReceipt, [userOpHash]);
+    if (!result) return null;
+    return {
+      userOpHash: result.userOpHash,
+      sender: result.sender,
+      nonce: BigInt(result.nonce),
+      paymaster: result.paymaster,
+      actualGasCost: BigInt(result.actualGasCost),
+      actualGasUsed: BigInt(result.actualGasUsed),
+      success: result.success,
+      reason: result.reason,
+      receipt: {
+        transactionHash: result.receipt.transactionHash,
+        blockNumber: BigInt(result.receipt.blockNumber),
+        blockHash: result.receipt.blockHash
+      }
+    };
+  }
+  /**
+   * Get supported EntryPoints
+   */
+  async getSupportedEntryPoints() {
+    return this.rpcCall(BUNDLER_METHODS.supportedEntryPoints, []);
+  }
+  /**
+   * Get chain ID from bundler
+   */
+  async getChainId() {
+    const result = await this.rpcCall(BUNDLER_METHODS.chainId, []);
+    return Number(result);
+  }
+  /**
+   * Wait for UserOperation receipt with polling
+   */
+  async waitForReceipt(userOpHash, options = {}) {
+    const timeout = options.timeout ?? 6e4;
+    const pollingInterval = options.pollingInterval ?? 2e3;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const receipt = await this.getUserOperationReceipt(userOpHash);
+      if (receipt) {
+        return receipt;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+    }
+    throw new BundlerError(
+      `Timeout waiting for UserOperation receipt: ${userOpHash}`
+    );
+  }
+  /**
+   * Pack UserOperation for RPC (convert bigints to hex strings)
+   */
+  packForRpc(userOp) {
+    return {
+      sender: userOp.sender,
+      nonce: this.toHex(userOp.nonce),
+      initCode: userOp.initCode,
+      callData: userOp.callData,
+      accountGasLimits: packAccountGasLimits(
+        userOp.verificationGasLimit,
+        userOp.callGasLimit
+      ),
+      preVerificationGas: this.toHex(userOp.preVerificationGas),
+      gasFees: packGasFees(userOp.maxPriorityFeePerGas, userOp.maxFeePerGas),
+      paymasterAndData: userOp.paymasterAndData,
+      signature: userOp.signature
+    };
+  }
+  /**
+   * Convert bigint to hex string
+   */
+  toHex(value) {
+    return `0x${value.toString(16)}`;
+  }
+  /**
+   * Make a JSON-RPC call to the bundler
+   */
+  async rpcCall(method, params) {
+    const request = {
+      jsonrpc: "2.0",
+      id: ++this.requestId,
+      method,
+      params
+    };
+    const response = await fetch(this.bundlerUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      throw new BundlerError(
+        `HTTP error: ${response.status} ${response.statusText}`
+      );
+    }
+    const json = await response.json();
+    if (json.error) {
+      throw new BundlerError(json.error.message, json.error.code, json.error.data);
+    }
+    return json.result;
+  }
+};
+function createBundlerClient(config) {
+  return new BundlerClient(config);
+}
+
+// src/erc4337/paymaster.ts
+import { concat as concat2, pad as pad2, toHex as toHex2 } from "viem";
+var PaymasterClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Get paymaster data for a UserOperation
+   */
+  async getPaymasterData(userOp, chainId, entryPoint, context) {
+    switch (this.config.type) {
+      case "verifying":
+        return this.getVerifyingPaymasterData(userOp, chainId, entryPoint);
+      case "sponsoring":
+        return this.getSponsoringPaymasterData(
+          userOp,
+          chainId,
+          entryPoint,
+          context
+        );
+      case "token":
+        return this.getTokenPaymasterData(userOp, chainId, entryPoint);
+      default:
+        throw new Error(`Unknown paymaster type: ${this.config.type}`);
+    }
+  }
+  /**
+   * Get gas estimates including paymaster gas
+   */
+  async estimatePaymasterGas(userOp, _chainId) {
+    return {
+      verificationGasLimit: DEFAULT_GAS_LIMITS.verificationGasLimit,
+      callGasLimit: DEFAULT_GAS_LIMITS.callGasLimit,
+      preVerificationGas: DEFAULT_GAS_LIMITS.preVerificationGas,
+      paymasterVerificationGasLimit: DEFAULT_GAS_LIMITS.paymasterVerificationGasLimit,
+      paymasterPostOpGasLimit: DEFAULT_GAS_LIMITS.paymasterPostOpGasLimit
+    };
+  }
+  /**
+   * Check if the paymaster will sponsor this operation
+   */
+  async willSponsor(userOp, chainId, entryPoint, context) {
+    if (!this.config.url) {
+      return true;
+    }
+    try {
+      const response = await fetch(`${this.config.url}/check`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          userOp: this.serializeUserOp(userOp),
+          chainId,
+          entryPoint,
+          context
+        })
+      });
+      if (!response.ok) return false;
+      const result = await response.json();
+      return result.willSponsor;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get verifying paymaster data (off-chain signature)
+   */
+  async getVerifyingPaymasterData(userOp, chainId, entryPoint) {
+    if (this.config.url) {
+      return this.callPaymasterService(userOp, chainId, entryPoint);
+    }
+    return {
+      paymaster: this.config.address,
+      paymasterVerificationGasLimit: DEFAULT_GAS_LIMITS.paymasterVerificationGasLimit,
+      paymasterPostOpGasLimit: DEFAULT_GAS_LIMITS.paymasterPostOpGasLimit,
+      paymasterData: "0x"
+    };
+  }
+  /**
+   * Get sponsoring paymaster data (third-party pays)
+   */
+  async getSponsoringPaymasterData(userOp, chainId, entryPoint, context) {
+    if (!this.config.url) {
+      throw new Error("Sponsoring paymaster requires a service URL");
+    }
+    const response = await fetch(`${this.config.url}/sponsor`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        userOp: this.serializeUserOp(userOp),
+        chainId,
+        entryPoint,
+        context
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Paymaster rejected sponsorship: ${error}`);
+    }
+    const result = await response.json();
+    return {
+      paymaster: result.paymaster,
+      paymasterVerificationGasLimit: result.paymasterVerificationGasLimit,
+      paymasterPostOpGasLimit: result.paymasterPostOpGasLimit,
+      paymasterData: result.paymasterData
+    };
+  }
+  /**
+   * Get token paymaster data (pay gas with ERC20)
+   */
+  async getTokenPaymasterData(userOp, chainId, entryPoint) {
+    const tokenAddress = this.config.options?.tokenAddress;
+    if (!tokenAddress) {
+      throw new Error("Token paymaster requires tokenAddress in options");
+    }
+    if (this.config.url) {
+      return this.callPaymasterService(userOp, chainId, entryPoint, {
+        tokenAddress
+      });
+    }
+    return {
+      paymaster: this.config.address,
+      paymasterVerificationGasLimit: DEFAULT_GAS_LIMITS.paymasterVerificationGasLimit,
+      paymasterPostOpGasLimit: DEFAULT_GAS_LIMITS.paymasterPostOpGasLimit,
+      paymasterData: tokenAddress
+      // Token address as data
+    };
+  }
+  /**
+   * Call paymaster service API
+   */
+  async callPaymasterService(userOp, chainId, entryPoint, context) {
+    if (!this.config.url) {
+      throw new Error("Paymaster service URL not configured");
+    }
+    const response = await fetch(`${this.config.url}/getPaymasterData`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        userOp: this.serializeUserOp(userOp),
+        chainId,
+        entryPoint,
+        context
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Paymaster service error: ${error}`);
+    }
+    const result = await response.json();
+    return {
+      paymaster: result.paymaster,
+      paymasterVerificationGasLimit: BigInt(result.paymasterVerificationGasLimit),
+      paymasterPostOpGasLimit: BigInt(result.paymasterPostOpGasLimit),
+      paymasterData: result.paymasterData
+    };
+  }
+  /**
+   * Serialize UserOperation for API calls
+   */
+  serializeUserOp(userOp) {
+    const result = {};
+    if (userOp.sender) result.sender = userOp.sender;
+    if (userOp.nonce !== void 0)
+      result.nonce = `0x${userOp.nonce.toString(16)}`;
+    if (userOp.initCode) result.initCode = userOp.initCode;
+    if (userOp.callData) result.callData = userOp.callData;
+    if (userOp.verificationGasLimit !== void 0)
+      result.verificationGasLimit = `0x${userOp.verificationGasLimit.toString(16)}`;
+    if (userOp.callGasLimit !== void 0)
+      result.callGasLimit = `0x${userOp.callGasLimit.toString(16)}`;
+    if (userOp.preVerificationGas !== void 0)
+      result.preVerificationGas = `0x${userOp.preVerificationGas.toString(16)}`;
+    if (userOp.maxPriorityFeePerGas !== void 0)
+      result.maxPriorityFeePerGas = `0x${userOp.maxPriorityFeePerGas.toString(16)}`;
+    if (userOp.maxFeePerGas !== void 0)
+      result.maxFeePerGas = `0x${userOp.maxFeePerGas.toString(16)}`;
+    if (userOp.paymasterAndData) result.paymasterAndData = userOp.paymasterAndData;
+    if (userOp.signature) result.signature = userOp.signature;
+    return result;
+  }
+};
+function createPaymasterClient(config) {
+  return new PaymasterClient(config);
+}
+function encodePaymasterAndData(data) {
+  return concat2([
+    data.paymaster,
+    pad2(toHex2(data.paymasterVerificationGasLimit), { size: 16 }),
+    pad2(toHex2(data.paymasterPostOpGasLimit), { size: 16 }),
+    data.paymasterData
+  ]);
+}
+function decodePaymasterAndData(paymasterAndData) {
+  if (paymasterAndData === "0x" || paymasterAndData.length < 86) {
+    return null;
+  }
+  const paymaster = `0x${paymasterAndData.slice(2, 42)}`;
+  const paymasterVerificationGasLimit = BigInt(
+    `0x${paymasterAndData.slice(42, 74)}`
+  );
+  const paymasterPostOpGasLimit = BigInt(`0x${paymasterAndData.slice(74, 106)}`);
+  const paymasterData = `0x${paymasterAndData.slice(106)}`;
+  return {
+    paymaster,
+    paymasterVerificationGasLimit,
+    paymasterPostOpGasLimit,
+    paymasterData
+  };
+}
+
+// src/erc4337/t402.ts
+import { encodeFunctionData as encodeFunctionData2 } from "viem";
+var ERC20_TRANSFER_ABI = [
+  {
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "transfer",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var EIP3009_TRANSFER_ABI = [
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    name: "transferWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var GaslessT402Client = class {
+  constructor(config) {
+    this.signer = config.signer;
+    this.builder = new UserOpBuilder();
+    this.bundler = new BundlerClient(config.bundler);
+    this.paymaster = config.paymaster ? new PaymasterClient(config.paymaster) : void 0;
+    this.chainId = config.chainId;
+    this.publicClient = config.publicClient;
+  }
+  /**
+   * Execute a T402 payment via ERC-4337
+   *
+   * This submits the payment as a UserOperation which can be:
+   * - Sponsored by a paymaster (truly gasless)
+   * - Paid from the smart account's balance
+   */
+  async executePayment(params) {
+    const callData = params.authorization ? this.buildAuthorizedTransferCallData(params) : this.buildTransferCallData(params);
+    const intent = {
+      to: params.tokenAddress,
+      value: 0n,
+      data: callData
+    };
+    const gasEstimate = await this.estimateGas(intent);
+    const paymasterData = await this.getPaymasterData(gasEstimate);
+    const userOp = await this.builder.buildUserOp(
+      this.signer,
+      intent,
+      this.publicClient,
+      gasEstimate,
+      paymasterData
+    );
+    const signedUserOp = await this.builder.signUserOp(
+      userOp,
+      this.signer,
+      this.publicClient,
+      this.chainId
+    );
+    return this.bundler.sendUserOperation(signedUserOp);
+  }
+  /**
+   * Execute multiple T402 payments in a single UserOperation
+   */
+  async executeBatchPayments(payments) {
+    const intents = payments.map((params) => ({
+      to: params.tokenAddress,
+      value: 0n,
+      data: params.authorization ? this.buildAuthorizedTransferCallData(params) : this.buildTransferCallData(params)
+    }));
+    const gasEstimate = await this.estimateBatchGas(intents);
+    const paymasterData = await this.getPaymasterData(gasEstimate);
+    const userOp = await this.builder.buildBatchUserOp(
+      this.signer,
+      intents,
+      this.publicClient,
+      gasEstimate,
+      paymasterData
+    );
+    const signedUserOp = await this.builder.signUserOp(
+      userOp,
+      this.signer,
+      this.publicClient,
+      this.chainId
+    );
+    return this.bundler.sendUserOperation(signedUserOp);
+  }
+  /**
+   * Check if a payment can be sponsored (gasless)
+   */
+  async canSponsor(params) {
+    if (!this.paymaster) return false;
+    const intent = {
+      to: params.tokenAddress,
+      value: 0n,
+      data: this.buildTransferCallData(params)
+    };
+    const sender = await this.signer.getAddress();
+    return this.paymaster.willSponsor(
+      { sender, callData: this.signer.encodeExecute(intent.to, 0n, intent.data) },
+      this.chainId,
+      ENTRYPOINT_V07_ADDRESS
+    );
+  }
+  /**
+   * Get the smart account address
+   */
+  async getAccountAddress() {
+    return this.signer.getAddress();
+  }
+  /**
+   * Check if the smart account is deployed
+   */
+  async isAccountDeployed() {
+    return this.signer.isDeployed();
+  }
+  /**
+   * Build call data for a simple ERC20 transfer
+   */
+  buildTransferCallData(params) {
+    return encodeFunctionData2({
+      abi: ERC20_TRANSFER_ABI,
+      functionName: "transfer",
+      args: [params.to, params.amount]
+    });
+  }
+  /**
+   * Build call data for an authorized transfer (EIP-3009)
+   */
+  buildAuthorizedTransferCallData(params) {
+    if (!params.authorization) {
+      throw new Error("Authorization required for authorized transfer");
+    }
+    const sig = params.authorization.signature;
+    const r = `0x${sig.slice(2, 66)}`;
+    const s = `0x${sig.slice(66, 130)}`;
+    const v = parseInt(sig.slice(130, 132), 16);
+    return encodeFunctionData2({
+      abi: EIP3009_TRANSFER_ABI,
+      functionName: "transferWithAuthorization",
+      args: [
+        params.to,
+        // from (will be overwritten by smart account)
+        params.to,
+        params.amount,
+        params.authorization.validAfter,
+        params.authorization.validBefore,
+        params.authorization.nonce,
+        v,
+        r,
+        s
+      ]
+    });
+  }
+  /**
+   * Estimate gas for a single transaction
+   */
+  async estimateGas(intent) {
+    const sender = await this.signer.getAddress();
+    const callData = this.signer.encodeExecute(
+      intent.to,
+      intent.value ?? 0n,
+      intent.data ?? "0x"
+    );
+    try {
+      return await this.bundler.estimateUserOperationGas({
+        sender,
+        callData
+      });
+    } catch {
+      return {
+        verificationGasLimit: 150000n,
+        callGasLimit: 100000n,
+        preVerificationGas: 50000n
+      };
+    }
+  }
+  /**
+   * Estimate gas for a batch transaction
+   */
+  async estimateBatchGas(intents) {
+    const sender = await this.signer.getAddress();
+    const callData = this.signer.encodeExecuteBatch(
+      intents.map((i) => i.to),
+      intents.map((i) => i.value ?? 0n),
+      intents.map((i) => i.data ?? "0x")
+    );
+    try {
+      return await this.bundler.estimateUserOperationGas({
+        sender,
+        callData
+      });
+    } catch {
+      return {
+        verificationGasLimit: 150000n,
+        callGasLimit: 100000n * BigInt(intents.length),
+        preVerificationGas: 50000n
+      };
+    }
+  }
+  /**
+   * Get paymaster data if configured
+   */
+  async getPaymasterData(_gasEstimate) {
+    if (!this.paymaster) return void 0;
+    const sender = await this.signer.getAddress();
+    return this.paymaster.getPaymasterData(
+      { sender },
+      this.chainId,
+      ENTRYPOINT_V07_ADDRESS
+    );
+  }
+};
+function createGaslessT402Client(config) {
+  return new GaslessT402Client(config);
+}
+export {
+  ACCOUNT_ABI,
+  BUNDLER_METHODS,
+  BundlerClient,
+  BundlerError,
+  DEFAULT_GAS_LIMITS,
+  ENTRYPOINT_V06_ADDRESS,
+  ENTRYPOINT_V07_ABI,
+  ENTRYPOINT_V07_ADDRESS,
+  ExactEvmScheme,
+  ExactLegacyEvmScheme as ExactLegacyEvmClientScheme,
+  ExactLegacyEvmScheme3 as ExactLegacyEvmFacilitatorScheme,
+  ExactLegacyEvmScheme2 as ExactLegacyEvmServerScheme,
+  GaslessT402Client,
+  LAYERZERO_ENDPOINT_IDS,
+  LAYERZERO_ENDPOINT_V2,
+  PaymasterClient,
+  PaymasterType,
+  TOKEN_PRIORITY,
+  TOKEN_REGISTRY,
+  USDC_ADDRESSES,
+  USDT0_ADDRESSES,
+  USDT0_OFT_ADDRESSES,
+  USDT_LEGACY_ADDRESSES,
+  Usdt0Bridge,
+  UserOpBuilder,
+  addressToBytes32,
+  authorizationTypes,
+  bytes32ToAddress,
+  createBundlerClient,
+  createGaslessT402Client,
+  createPaymasterClient,
+  createUsdt0Bridge,
+  createUserOpBuilder,
+  decodePaymasterAndData,
+  eip3009ABI,
+  encodePaymasterAndData,
+  erc20LegacyABI,
+  getBridgeableChains,
+  getDefaultToken,
+  getEIP712Domain,
+  getEndpointId,
+  getNetworkTokens,
+  getNetworksForToken,
+  getTokenByAddress,
+  getTokenConfig,
+  getUsdt0Networks,
+  getUsdt0OftAddress,
+  legacyAuthorizationTypes,
+  packAccountGasLimits,
+  packGasFees,
+  supportsBridging,
+  supportsEIP3009,
+  toClientEvmSigner,
+  toFacilitatorEvmSigner,
+  unpackAccountGasLimits,
+  unpackGasFees
+};
+//# sourceMappingURL=index.mjs.map