@usewhisk/cctp 0.0.0 → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,4018 @@
+'use strict';
+
+var stellarSdk = require('@stellar/stellar-sdk');
+var starknet = require('starknet');
+var viem = require('viem');
+var web3_js = require('@solana/web3.js');
+var sha256 = require('@noble/hashes/sha256');
+var splToken = require('@solana/spl-token');
+var buffer = require('buffer');
+
+// src/errors.ts
+var CctpError = class extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "CctpError";
+    this.code = code;
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+var InvalidInputError = class extends CctpError {
+  constructor(code, message, cause) {
+    super(code, message, cause);
+    this.name = "InvalidInputError";
+  }
+};
+var IrisError = class extends CctpError {
+  constructor(code, message, cause) {
+    super(code, message, cause);
+    this.name = "IrisError";
+  }
+};
+var IrisHttpError = class extends IrisError {
+  status;
+  bodySnippet;
+  url;
+  constructor(status, url, bodySnippet) {
+    super(
+      "iris_http",
+      `Iris ${status} on ${url}: ${bodySnippet.slice(0, 200)}`
+    );
+    this.name = "IrisHttpError";
+    this.status = status;
+    this.url = url;
+    this.bodySnippet = bodySnippet;
+  }
+};
+var IrisRateLimitedError = class extends IrisError {
+  retryAt;
+  host;
+  constructor(host, retryAt) {
+    super(
+      "iris_rate_limited",
+      `Iris rate limit reached on ${host}; requests resume at ${new Date(retryAt).toISOString()}`
+    );
+    this.name = "IrisRateLimitedError";
+    this.host = host;
+    this.retryAt = retryAt;
+  }
+};
+var IrisNetworkError = class extends IrisError {
+  constructor(message, cause) {
+    super("iris_network", message, cause);
+    this.name = "IrisNetworkError";
+  }
+};
+var IrisParseError = class extends IrisError {
+  constructor(message, cause) {
+    super("iris_parse", message, cause);
+    this.name = "IrisParseError";
+  }
+};
+var IrisAbortedError = class extends IrisError {
+  constructor(message) {
+    super("iris_aborted", message);
+    this.name = "IrisAbortedError";
+  }
+};
+var ProtocolError = class extends CctpError {
+  constructor(code, message, cause) {
+    super(code, message, cause);
+    this.name = "ProtocolError";
+  }
+};
+var UnsupportedError = class extends CctpError {
+  constructor(code, message) {
+    super(code, message);
+    this.name = "UnsupportedError";
+  }
+};
+function isCctpError(value) {
+  return value instanceof CctpError;
+}
+
+// src/chains/constants.ts
+var TOKEN_MESSENGER_V2_EVM_MAINNET = "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d";
+var MESSAGE_TRANSMITTER_V2_EVM_MAINNET = "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64";
+var TOKEN_MESSENGER_V2_EVM_TESTNET = "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA";
+var MESSAGE_TRANSMITTER_V2_EVM_TESTNET = "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275";
+var TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET = "0x71f54F818671cD0D7ea140Da213e5C8b5C92a408";
+var TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET = "0x8745D906D67C346E5eb1aEEED38Eb87F34DF0C0A";
+var TOKEN_MESSENGER_MINTER_V2_SOLANA = "CCTPV2vPZJS2u2BBsUoscuikbYjnpFmbFsvVuJdgUMQe";
+var MESSAGE_TRANSMITTER_V2_SOLANA = "CCTPV2Sm4AdWt5296sk4P66VBZ7bEhcARwFaaS9YPbeC";
+var USDC_SPL_MAINNET = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var USDC_SPL_DEVNET = "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU";
+var SOLANA_CCTP_DOMAIN = 5;
+var TOKEN_MESSENGER_MINTER_STELLAR_MAINNET = "CAE2G5Z77UP7GYPYGFOWFGW7C7J6I4YP2AFGSADRKQY62SYUFLPNFTXL";
+var MESSAGE_TRANSMITTER_STELLAR_MAINNET = "CACMENFFJPJMSDAJQLX4R7K3SFZIW2LJSE3R2UMLGSWHFHS353FVXAZV";
+var CCTP_FORWARDER_STELLAR_MAINNET = "CBZL2IH7F6BIDAA3WBNXYKIXSATJGMSW7K5P5MJ6STX5RXN47TZJDF5T";
+var TOKEN_MESSENGER_MINTER_STELLAR_TESTNET = "CDNG7HXAPBWICI2E3AUBP3YZWZELJLYSB6F5CC7WLDTLTHVM74SLRTHP";
+var MESSAGE_TRANSMITTER_STELLAR_TESTNET = "CBJ6MTCKKZG73PMDZCJMSFRD7DQEMI4FKDH7CGDSV4W6FHCRBCQAVVJY";
+var CCTP_FORWARDER_STELLAR_TESTNET = "CA66Q2WFBND6V4UEB7RD4SAXSVIWMD6RA4X3U32ELVFGXV5PJK4T4VSZ";
+var USDC_ISSUER_STELLAR_MAINNET = "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN";
+var USDC_ISSUER_STELLAR_TESTNET = "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5";
+var STELLAR_NETWORK_PASSPHRASE_MAINNET = "Public Global Stellar Network ; September 2015";
+var STELLAR_NETWORK_PASSPHRASE_TESTNET = "Test SDF Network ; September 2015";
+var STELLAR_CCTP_DOMAIN = 27;
+var STELLAR_USDC_DECIMALS = 7;
+var CCTP_USDC_DECIMALS = 6;
+var TOKEN_MESSENGER_MINTER_V2_STARKNET_MAINNET = "0x07d421B9cA8aA32DF259965cDA8ACb93F7599F69209A41872AE84638B2A20F2a";
+var MESSAGE_TRANSMITTER_V2_STARKNET_MAINNET = "0x02EBB5777B6dD8B26ea11D68Fdf1D2c85cD2099335328Be845a28c77A8AEf183";
+var TOKEN_MESSENGER_MINTER_V2_STARKNET_SEPOLIA = "0x04bDdE1E09a4B09a2F95d893D94a967b7717eB85A3f6dEcA8c080Ee01fBc3370";
+var MESSAGE_TRANSMITTER_V2_STARKNET_SEPOLIA = "0x04db7926C64f1f32a840F3Fa95cB551f3801a3600Bae87aF87807A54DCE12Fe8";
+var USDC_STARKNET_MAINNET = "0x033068F6539f8e6e6b131e6B2B814e6c34A5224bC66947c47DaB9dFeE93b35fb";
+var USDC_STARKNET_SEPOLIA = "0x0512feAc6339Ff7889822cb5aA2a86C848e9D392bB0E3E237C008674feeD8343";
+var STARKNET_CHAIN_ID_MAINNET = "0x534e5f4d41494e";
+var STARKNET_CHAIN_ID_SEPOLIA = "0x534e5f5345504f4c4941";
+var STARKNET_CCTP_DOMAIN = 25;
+
+// src/chains/mainnet.ts
+var Ethereum = {
+  id: "Ethereum",
+  label: "Ethereum",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 1,
+  cctpDomain: 0,
+  usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: [
+    "https://ethereum-rpc.publicnode.com",
+    "https://ethereum.publicnode.com"
+  ],
+  explorerUrl: "https://etherscan.io",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var Avalanche = {
+  id: "Avalanche",
+  label: "Avalanche",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 43114,
+  cctpDomain: 1,
+  usdc: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "AVAX", decimals: 18 },
+  defaultRpcUrls: ["https://api.avax.network/ext/bc/C/rpc"],
+  explorerUrl: "https://explorer.avax.network/c-chain",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var Optimism = {
+  id: "Optimism",
+  label: "OP Mainnet",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 10,
+  cctpDomain: 2,
+  usdc: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://mainnet.optimism.io"],
+  explorerUrl: "https://explorer.optimism.io",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var Arbitrum = {
+  id: "Arbitrum",
+  label: "Arbitrum",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 42161,
+  cctpDomain: 3,
+  usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://arb1.arbitrum.io/rpc"],
+  explorerUrl: "https://arbiscan.io",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var Base = {
+  id: "Base",
+  label: "Base",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 8453,
+  cctpDomain: 6,
+  usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://mainnet.base.org"],
+  explorerUrl: "https://basescan.org",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var Polygon = {
+  id: "Polygon",
+  label: "Polygon PoS",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 137,
+  cctpDomain: 7,
+  usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "POL", decimals: 18 },
+  defaultRpcUrls: [
+    "https://polygon.drpc.org",
+    "https://polygon.publicnode.com"
+  ],
+  explorerUrl: "https://polygonscan.com",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var Unichain = {
+  id: "Unichain",
+  label: "Unichain",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 130,
+  cctpDomain: 10,
+  usdc: "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://mainnet.unichain.org"],
+  explorerUrl: "https://uniscan.xyz",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var Linea = {
+  id: "Linea",
+  label: "Linea",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 59144,
+  cctpDomain: 11,
+  usdc: "0x176211869cA2b568f2A7D4EE941E073a821EE1ff",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.linea.build"],
+  explorerUrl: "https://lineascan.build",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var Codex = {
+  id: "Codex",
+  label: "Codex",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 81224,
+  cctpDomain: 12,
+  usdc: "0xd996633a415985DBd7D6D12f4A4343E31f5037cf",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.codex.xyz"],
+  explorerUrl: "https://explorer.codex.xyz",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var Sonic = {
+  id: "Sonic",
+  label: "Sonic",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 146,
+  cctpDomain: 13,
+  usdc: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "S", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.soniclabs.com"],
+  explorerUrl: "https://sonicscan.org",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var WorldChain = {
+  id: "World_Chain",
+  label: "World Chain",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 480,
+  cctpDomain: 14,
+  usdc: "0x79A02482A880bCE3F13e09Da970dC34db4CD24d1",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://worldchain-mainnet.g.alchemy.com/public"],
+  explorerUrl: "https://worldscan.org",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var Monad = {
+  id: "Monad",
+  label: "Monad",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 143,
+  cctpDomain: 15,
+  usdc: "0x754704Bc059F8C67012fEd69BC8A327a5aafb603",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "MON", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"],
+  explorerUrl: "https://monadvision.com",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var Sei = {
+  id: "Sei",
+  label: "Sei",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 1329,
+  cctpDomain: 16,
+  usdc: "0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "SEI", decimals: 18 },
+  defaultRpcUrls: ["https://evm-rpc.sei-apis.com"],
+  explorerUrl: "https://seiscan.io",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var XDC = {
+  id: "XDC",
+  label: "XDC",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 50,
+  cctpDomain: 18,
+  usdc: "0xfA2958CB79b0491CC627c1557F441eF849Ca8eb1",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "XDC", decimals: 18 },
+  defaultRpcUrls: ["https://erpc.xinfin.network", "https://rpc.xinfin.network"],
+  explorerUrl: "https://xdcscan.io",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var HyperEVM = {
+  id: "HyperEVM",
+  label: "HyperEVM",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 999,
+  cctpDomain: 19,
+  usdc: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "HYPE", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.hyperliquid.xyz/evm"],
+  explorerUrl: "https://hyperevmscan.io",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var Ink = {
+  id: "Ink",
+  label: "Ink",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 57073,
+  cctpDomain: 21,
+  usdc: "0x2D270e6886d130D724215A266106e6832161EAEd",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: [
+    "https://rpc-gel.inkonchain.com",
+    "https://rpc-qnd.inkonchain.com"
+  ],
+  explorerUrl: "https://explorer.inkonchain.com",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var Plume = {
+  id: "Plume",
+  label: "Plume",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 98866,
+  cctpDomain: 22,
+  usdc: "0x222365EF19F7947e5484218551B56bb3965Aa7aF",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "PLUME", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.plume.org"],
+  explorerUrl: "https://explorer.plume.org",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var Arc = {
+  id: "Arc",
+  label: "Arc",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 5042,
+  cctpDomain: 26,
+  usdc: "0x3600000000000000000000000000000000000000",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET,
+  nativeCurrency: { symbol: "USDC", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.mainnet.arc.io"],
+  explorerUrl: "https://explorer.arc.io",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var Edge = {
+  id: "Edge",
+  label: "EDGE",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 3343,
+  cctpDomain: 28,
+  usdc: "0x98d2919b9A214E6Fa5384AC81E6864bA686Ad74c",
+  usdcDecimals: 6,
+  tokenMessenger: "0x98706A006bc632Df31CAdFCBD43F38887ce2ca5c",
+  messageTransmitter: "0x5b61381Fc9e58E70EfC13a4A97516997019198ee",
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://edge-mainnet.g.alchemy.com/public"],
+  explorerUrl: "https://pro.edgex.exchange/en-US/explorer",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var Injective = {
+  id: "Injective",
+  label: "Injective",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 1776,
+  cctpDomain: 29,
+  usdc: "0xa00C59fF5a080D2b954d0c75e46E22a0c371235a",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  nativeCurrency: { symbol: "INJ", decimals: 18 },
+  defaultRpcUrls: [
+    "https://sentry.evm-rpc.injective.network",
+    "https://evm.archival.chain.virtual.json-rpc.injective.network"
+  ],
+  explorerUrl: "https://blockscout.injective.network",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var Morph = {
+  id: "Morph",
+  label: "Morph",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 2818,
+  cctpDomain: 30,
+  usdc: "0xCfb1186F4e93D60E60a8bDd997427D1F33bc372B",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://rpc-bgw.morph.network"],
+  explorerUrl: "https://explorer.morph.network",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var Pharos = {
+  id: "Pharos",
+  label: "Pharos",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 1672,
+  cctpDomain: 31,
+  usdc: "0xC879C018dB60520F4355C26eD1a6D572cdAC1815",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  nativeCurrency: { symbol: "PROS", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.pharos.xyz"],
+  explorerUrl: "https://www.pharosscan.xyz",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var Cronos = {
+  id: "Cronos",
+  label: "Cronos",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 25,
+  cctpDomain: 32,
+  usdc: "0x3D7F2C478aAfdB65542BCB44bCeeC05849999d2D",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  nativeCurrency: { symbol: "CRO", decimals: 18 },
+  defaultRpcUrls: ["https://evm.cronos.com"],
+  explorerUrl: "https://explorer.cronos.com",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var Plasma = {
+  id: "Plasma",
+  label: "Plasma",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 9745,
+  cctpDomain: 33,
+  usdc: "0x2d661C89D812261039AF9764eceaAee884f5F67F",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  nativeCurrency: { symbol: "XPL", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.plasma.to"],
+  explorerUrl: "https://plasmascan.to",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var XLayer = {
+  id: "X_Layer",
+  label: "X Layer",
+  ecosystem: "evm",
+  network: "mainnet",
+  evmChainId: 196,
+  cctpDomain: 37,
+  usdc: "0xB6CEceAB302E2E4948951eE7843FC24E92933061",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_MAINNET,
+  nativeCurrency: { symbol: "OKB", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.xlayer.tech", "https://xlayerrpc.okx.com"],
+  explorerUrl: "https://www.okx.com/web3/explorer/xlayer",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var EVM_MAINNET_CHAINS = [
+  Ethereum,
+  Avalanche,
+  Optimism,
+  Arbitrum,
+  Base,
+  Polygon,
+  Unichain,
+  Linea,
+  Codex,
+  Sonic,
+  WorldChain,
+  Monad,
+  Sei,
+  XDC,
+  HyperEVM,
+  Ink,
+  Plume,
+  Arc,
+  Edge,
+  Injective,
+  Morph,
+  Pharos,
+  Cronos,
+  Plasma,
+  XLayer
+];
+
+// src/chains/testnet.ts
+var EthereumSepolia = {
+  id: "Ethereum_Sepolia",
+  label: "Ethereum Sepolia",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 11155111,
+  cctpDomain: 0,
+  usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://ethereum-sepolia-rpc.publicnode.com"],
+  explorerUrl: "https://sepolia.etherscan.io",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var AvalancheFuji = {
+  id: "Avalanche_Fuji",
+  label: "Avalanche Fuji",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 43113,
+  cctpDomain: 1,
+  usdc: "0x5425890298aed601595a70AB815c96711a31Bc65",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "AVAX", decimals: 18 },
+  defaultRpcUrls: ["https://api.avax-test.network/ext/bc/C/rpc"],
+  explorerUrl: "https://explorer-test.avax.network/c-chain",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var OptimismSepolia = {
+  id: "Optimism_Sepolia",
+  label: "OP Sepolia",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 11155420,
+  cctpDomain: 2,
+  usdc: "0x5fd84259d66Cd46123540766Be93DFE6D43130D7",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://sepolia.optimism.io"],
+  explorerUrl: "https://testnet-explorer.optimism.io",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var ArbitrumSepolia = {
+  id: "Arbitrum_Sepolia",
+  label: "Arbitrum Sepolia",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 421614,
+  cctpDomain: 3,
+  usdc: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://sepolia-rollup.arbitrum.io/rpc"],
+  explorerUrl: "https://sepolia.arbiscan.io",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var BaseSepolia = {
+  id: "Base_Sepolia",
+  label: "Base Sepolia",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 84532,
+  cctpDomain: 6,
+  usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://sepolia.base.org"],
+  explorerUrl: "https://sepolia.basescan.org",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var PolygonAmoyTestnet = {
+  id: "Polygon_Amoy_Testnet",
+  label: "Polygon PoS Amoy",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 80002,
+  cctpDomain: 7,
+  usdc: "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "POL", decimals: 18 },
+  defaultRpcUrls: ["https://polygon-amoy.drpc.org"],
+  explorerUrl: "https://amoy.polygonscan.com",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var UnichainSepolia = {
+  id: "Unichain_Sepolia",
+  label: "Unichain Sepolia",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 1301,
+  cctpDomain: 10,
+  usdc: "0x31d0220469e10c4E71834a79b1f276d740d3768F",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://sepolia.unichain.org"],
+  explorerUrl: "https://sepolia.uniscan.xyz",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var LineaSepolia = {
+  id: "Linea_Sepolia",
+  label: "Linea Sepolia",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 59141,
+  cctpDomain: 11,
+  usdc: "0xFEce4462D57bD51A6A552365A011b95f0E16d9B7",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.sepolia.linea.build"],
+  explorerUrl: "https://sepolia.lineascan.build",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var CodexTestnet = {
+  id: "Codex_Testnet",
+  label: "Codex Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 812242,
+  cctpDomain: 12,
+  usdc: "0x6d7f141b6819C2c9CC2f818e6ad549E7Ca090F8f",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.codex-stg.xyz"],
+  explorerUrl: "https://explorer.codex-stg.xyz",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var SonicTestnet = {
+  id: "Sonic_Testnet",
+  label: "Sonic Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 14601,
+  cctpDomain: 13,
+  usdc: "0x0BA304580ee7c9a980CF72e55f5Ed2E9fd30Bc51",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "S", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.testnet.soniclabs.com"],
+  explorerUrl: "https://testnet.sonicscan.org",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var WorldChainSepolia = {
+  id: "World_Chain_Sepolia",
+  label: "World Chain Sepolia",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 4801,
+  cctpDomain: 14,
+  usdc: "0x66145f38cBAC35Ca6F1Dfb4914dF98F1614aeA88",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://worldchain-sepolia.g.alchemy.com/public"],
+  explorerUrl: "https://worldchain-sepolia.explorer.alchemy.com",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: false
+  }
+};
+var MonadTestnet = {
+  id: "Monad_Testnet",
+  label: "Monad Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 10143,
+  cctpDomain: 15,
+  usdc: "0x534b2f3A21130d7a60830c2Df862319e593943A3",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  nativeCurrency: { symbol: "MON", decimals: 18 },
+  defaultRpcUrls: [
+    "https://testnet-rpc.monad.xyz",
+    "https://rpc-testnet.monadinfra.com"
+  ],
+  explorerUrl: "https://testnet.monadvision.com",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var SeiTestnet = {
+  id: "Sei_Testnet",
+  label: "Sei Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 1328,
+  cctpDomain: 16,
+  usdc: "0x4fCF1784B31630811181f670Aea7A7bEF803eaED",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "SEI", decimals: 18 },
+  defaultRpcUrls: ["https://evm-rpc-testnet.sei-apis.com"],
+  explorerUrl: "https://testnet.seiscan.io",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var XDCApothem = {
+  id: "XDC_Apothem",
+  label: "XDC Apothem",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 51,
+  cctpDomain: 18,
+  usdc: "0xb5AB69F7bBada22B28e79C8FFAECe55eF1c771D4",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "TXDC", decimals: 18 },
+  defaultRpcUrls: [
+    "https://rpc.apothem.network",
+    "https://erpc.apothem.network"
+  ],
+  explorerUrl: "https://testnet.xdcscan.com",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var HyperEVMTestnet = {
+  id: "HyperEVM_Testnet",
+  label: "HyperEVM Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 998,
+  cctpDomain: 19,
+  usdc: "0x2B3370eE501B4a559b57D449569354196457D8Ab",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "HYPE", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.hyperliquid-testnet.xyz/evm"],
+  explorerUrl: "https://app.hyperliquid-testnet.xyz/explorer",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var InkTestnet = {
+  id: "Ink_Testnet",
+  label: "Ink Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 763373,
+  cctpDomain: 21,
+  usdc: "0xFabab97dCE620294D2B0b0e46C68964e326300Ac",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: [
+    "https://rpc-gel-sepolia.inkonchain.com",
+    "https://rpc-qnd-sepolia.inkonchain.com"
+  ],
+  explorerUrl: "https://explorer-sepolia.inkonchain.com",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var PlumeTestnet = {
+  id: "Plume_Testnet",
+  label: "Plume Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 98867,
+  cctpDomain: 22,
+  usdc: "0xcB5f30e335672893c7eb944B374c196392C19D18",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "PLUME", decimals: 18 },
+  defaultRpcUrls: ["https://testnet-rpc.plume.org"],
+  explorerUrl: "https://testnet-explorer.plume.org",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var ArcTestnet = {
+  id: "Arc_Testnet",
+  label: "Arc Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 5042002,
+  cctpDomain: 26,
+  usdc: "0x3600000000000000000000000000000000000000",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  tokenMessengerWithFees: TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET,
+  nativeCurrency: { symbol: "USDC", decimals: 18 },
+  defaultRpcUrls: ["https://rpc.testnet.arc.io"],
+  explorerUrl: "https://explorer.testnet.arc.io",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: true,
+    upfrontFeeSource: true,
+    standardFeeSwitch: true
+  }
+};
+var EdgeTestnet = {
+  id: "Edge_Testnet",
+  label: "EDGE Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 33431,
+  cctpDomain: 28,
+  usdc: "0x2d9F7CAD728051AA35Ecdc472a14cf8cDF5CFD6B",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://edge-testnet.g.alchemy.com/public"],
+  explorerUrl: "https://edge-testnet.explorer.alchemy.com",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var InjectiveTestnet = {
+  id: "Injective_Testnet",
+  label: "Injective Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 1439,
+  cctpDomain: 29,
+  usdc: "0x0C382e685bbeeFE5d3d9C29e29E341fEE8E84C5d",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  nativeCurrency: { symbol: "INJ", decimals: 18 },
+  defaultRpcUrls: [
+    "https://k8s.testnet.json-rpc.injective.network",
+    "https://testnet.evm.archival.chain.virtual.json-rpc.injective.network"
+  ],
+  explorerUrl: "https://testnet.blockscout.injective.network",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var MorphTestnet = {
+  id: "Morph_Testnet",
+  label: "Morph Hoodi Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 2910,
+  cctpDomain: 30,
+  usdc: "0x7433b41C6c5e1d58D4Da99483609520255ab661B",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  nativeCurrency: { symbol: "ETH", decimals: 18 },
+  defaultRpcUrls: ["https://rpc-hoodi-bgw.morph.network"],
+  explorerUrl: "https://explorer-hoodi.morph.network",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var PharosTestnet = {
+  id: "Pharos_Testnet",
+  label: "Pharos Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 688689,
+  cctpDomain: 31,
+  usdc: "0xcfC8330f4BCAB529c625D12781b1C19466A9Fc8B",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  nativeCurrency: { symbol: "PHAROS", decimals: 18 },
+  defaultRpcUrls: ["https://atlantic.dplabs-internal.com"],
+  explorerUrl: "https://atlantic.pharosscan.xyz",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var CronosTestnet = {
+  id: "Cronos_Testnet",
+  label: "Cronos Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 338,
+  cctpDomain: 32,
+  usdc: "0xEb33dc5fac03833e132593659e1dE7256aB59794",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  nativeCurrency: { symbol: "tCRO", decimals: 18 },
+  defaultRpcUrls: ["https://evm-t3.cronos.com"],
+  explorerUrl: "https://explorer.cronos.com/testnet",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var PlasmaTestnet = {
+  id: "Plasma_Testnet",
+  label: "Plasma Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 9746,
+  cctpDomain: 33,
+  usdc: "0xE67Fb267022cBA8064Dd388CC2FED724F3120D9D",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  nativeCurrency: { symbol: "XPL", decimals: 18 },
+  defaultRpcUrls: ["https://testnet-rpc.plasma.to"],
+  explorerUrl: "https://testnet.plasmascan.to",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var XLayerTestnet = {
+  id: "X_Layer_Testnet",
+  label: "X Layer Testnet",
+  ecosystem: "evm",
+  network: "testnet",
+  evmChainId: 1952,
+  cctpDomain: 37,
+  usdc: "0xDec90b78111Ba2fc6FC6d84d8B9ec159A2d4b9B3",
+  usdcDecimals: 6,
+  tokenMessenger: TOKEN_MESSENGER_V2_EVM_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_EVM_TESTNET,
+  nativeCurrency: { symbol: "OKB", decimals: 18 },
+  defaultRpcUrls: [
+    "https://testrpc.xlayer.tech/terigon",
+    "https://xlayertestrpc.okx.com/terigon"
+  ],
+  explorerUrl: "https://www.okx.com/web3/explorer/xlayer-test",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: true
+  }
+};
+var EVM_TESTNET_CHAINS = [
+  EthereumSepolia,
+  AvalancheFuji,
+  OptimismSepolia,
+  ArbitrumSepolia,
+  BaseSepolia,
+  PolygonAmoyTestnet,
+  UnichainSepolia,
+  LineaSepolia,
+  CodexTestnet,
+  SonicTestnet,
+  WorldChainSepolia,
+  MonadTestnet,
+  SeiTestnet,
+  XDCApothem,
+  HyperEVMTestnet,
+  InkTestnet,
+  PlumeTestnet,
+  ArcTestnet,
+  EdgeTestnet,
+  InjectiveTestnet,
+  MorphTestnet,
+  PharosTestnet,
+  CronosTestnet,
+  PlasmaTestnet,
+  XLayerTestnet
+];
+
+// src/chains/solana.ts
+var Solana = {
+  id: "Solana",
+  label: "Solana",
+  ecosystem: "solana",
+  network: "mainnet",
+  cluster: "mainnet-beta",
+  cctpDomain: SOLANA_CCTP_DOMAIN,
+  usdc: USDC_SPL_MAINNET,
+  usdcDecimals: 6,
+  tokenMessengerMinter: TOKEN_MESSENGER_MINTER_V2_SOLANA,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_SOLANA,
+  nativeCurrency: { symbol: "SOL", decimals: 9 },
+  defaultRpcUrls: [
+    "https://api.mainnet.solana.com",
+    "https://api.mainnet-beta.solana.com"
+  ],
+  explorerUrl: "https://explorer.solana.com",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: false,
+    standardFeeSwitch: false
+  }
+};
+var SolanaDevnet = {
+  id: "Solana_Devnet",
+  label: "Solana Devnet",
+  ecosystem: "solana",
+  network: "testnet",
+  cluster: "devnet",
+  cctpDomain: SOLANA_CCTP_DOMAIN,
+  usdc: USDC_SPL_DEVNET,
+  usdcDecimals: 6,
+  tokenMessengerMinter: TOKEN_MESSENGER_MINTER_V2_SOLANA,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_SOLANA,
+  nativeCurrency: { symbol: "SOL", decimals: 9 },
+  defaultRpcUrls: ["https://api.devnet.solana.com"],
+  explorerUrl: "https://explorer.solana.com",
+  explorerQuery: "?cluster=devnet",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: true,
+    upfrontFeeSource: false,
+    standardFeeSwitch: false
+  }
+};
+function deriveUsdcSac(issuer, passphrase) {
+  return new stellarSdk.Asset("USDC", issuer).contractId(passphrase);
+}
+var USDC_SAC_STELLAR_MAINNET = deriveUsdcSac(
+  USDC_ISSUER_STELLAR_MAINNET,
+  STELLAR_NETWORK_PASSPHRASE_MAINNET
+);
+var USDC_SAC_STELLAR_TESTNET = deriveUsdcSac(
+  USDC_ISSUER_STELLAR_TESTNET,
+  STELLAR_NETWORK_PASSPHRASE_TESTNET
+);
+var Stellar = {
+  id: "Stellar",
+  label: "Stellar",
+  ecosystem: "stellar",
+  network: "mainnet",
+  stellarNetwork: "public",
+  networkPassphrase: STELLAR_NETWORK_PASSPHRASE_MAINNET,
+  cctpDomain: STELLAR_CCTP_DOMAIN,
+  usdcIssuer: USDC_ISSUER_STELLAR_MAINNET,
+  usdc: USDC_SAC_STELLAR_MAINNET,
+  usdcDecimals: STELLAR_USDC_DECIMALS,
+  tokenMessengerMinter: TOKEN_MESSENGER_MINTER_STELLAR_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_STELLAR_MAINNET,
+  cctpForwarder: CCTP_FORWARDER_STELLAR_MAINNET,
+  nativeCurrency: { symbol: "XLM", decimals: 7 },
+  defaultRpcUrls: [
+    "https://soroban-rpc.mainnet.stellar.gateway.fm",
+    "https://mainnet.sorobanrpc.com"
+  ],
+  explorerUrl: "https://stellar.expert/explorer/public",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: false
+  }
+};
+var StellarTestnet = {
+  id: "Stellar_Testnet",
+  label: "Stellar Testnet",
+  ecosystem: "stellar",
+  network: "testnet",
+  stellarNetwork: "testnet",
+  networkPassphrase: STELLAR_NETWORK_PASSPHRASE_TESTNET,
+  cctpDomain: STELLAR_CCTP_DOMAIN,
+  usdcIssuer: USDC_ISSUER_STELLAR_TESTNET,
+  usdc: USDC_SAC_STELLAR_TESTNET,
+  usdcDecimals: STELLAR_USDC_DECIMALS,
+  tokenMessengerMinter: TOKEN_MESSENGER_MINTER_STELLAR_TESTNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_STELLAR_TESTNET,
+  cctpForwarder: CCTP_FORWARDER_STELLAR_TESTNET,
+  nativeCurrency: { symbol: "XLM", decimals: 7 },
+  defaultRpcUrls: ["https://soroban-testnet.stellar.org"],
+  explorerUrl: "https://stellar.expert/explorer/testnet",
+  capabilities: {
+    fastSource: false,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: false
+  }
+};
+
+// src/chains/starknet.ts
+var Starknet = {
+  id: "Starknet",
+  label: "Starknet",
+  ecosystem: "starknet",
+  network: "mainnet",
+  starknetNetwork: "mainnet",
+  chainId: STARKNET_CHAIN_ID_MAINNET,
+  cctpDomain: STARKNET_CCTP_DOMAIN,
+  usdc: USDC_STARKNET_MAINNET,
+  usdcDecimals: 6,
+  tokenMessengerMinter: TOKEN_MESSENGER_MINTER_V2_STARKNET_MAINNET,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_STARKNET_MAINNET,
+  nativeCurrency: { symbol: "STRK", decimals: 18 },
+  defaultRpcUrls: ["https://starknet-rpc.publicnode.com"],
+  explorerUrl: "https://voyager.online",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: false
+  }
+};
+var StarknetSepolia = {
+  id: "Starknet_Sepolia",
+  label: "Starknet Sepolia",
+  ecosystem: "starknet",
+  network: "testnet",
+  starknetNetwork: "sepolia",
+  chainId: STARKNET_CHAIN_ID_SEPOLIA,
+  cctpDomain: STARKNET_CCTP_DOMAIN,
+  usdc: USDC_STARKNET_SEPOLIA,
+  usdcDecimals: 6,
+  tokenMessengerMinter: TOKEN_MESSENGER_MINTER_V2_STARKNET_SEPOLIA,
+  messageTransmitter: MESSAGE_TRANSMITTER_V2_STARKNET_SEPOLIA,
+  nativeCurrency: { symbol: "STRK", decimals: 18 },
+  defaultRpcUrls: ["https://starknet-sepolia-rpc.publicnode.com"],
+  explorerUrl: "https://sepolia.voyager.online",
+  capabilities: {
+    fastSource: true,
+    forwardingDestination: false,
+    upfrontFeeSource: false,
+    standardFeeSwitch: false
+  }
+};
+
+// src/chains/registry.ts
+var UnknownChainError = class extends InvalidInputError {
+  constructor(detail) {
+    super("invalid_chain", `Unknown chain: ${detail}`);
+    this.name = "UnknownChainError";
+  }
+};
+var CHAINS = [
+  ...EVM_MAINNET_CHAINS,
+  ...EVM_TESTNET_CHAINS,
+  Solana,
+  SolanaDevnet,
+  Stellar,
+  StellarTestnet,
+  Starknet,
+  StarknetSepolia
+];
+var ALL = CHAINS;
+var BY_ID = new Map(ALL.map((c) => [c.id, c]));
+var BY_EVM_CHAIN_ID = new Map(
+  ALL.filter(isEvmChain).map((c) => [c.evmChainId, c])
+);
+var BY_DOMAIN_AND_NETWORK = new Map(
+  ALL.map((c) => [`${c.cctpDomain}:${c.network}`, c])
+);
+function isEvmChain(chain) {
+  return chain.ecosystem === "evm";
+}
+function isSolanaChain(chain) {
+  return chain.ecosystem === "solana";
+}
+function isStellarChain(chain) {
+  return chain.ecosystem === "stellar";
+}
+function isStarknetChain(chain) {
+  return chain.ecosystem === "starknet";
+}
+function isChainId(value) {
+  return BY_ID.has(value);
+}
+function getChain(id) {
+  const chain = BY_ID.get(id);
+  if (!chain) throw new UnknownChainError(`id="${id}"`);
+  return chain;
+}
+function chainsByNetwork(network) {
+  return ALL.filter((c) => c.network === network);
+}
+function chainByEvmChainId(evmChainId) {
+  const chain = BY_EVM_CHAIN_ID.get(evmChainId);
+  if (!chain) throw new UnknownChainError(`evmChainId=${evmChainId}`);
+  return chain;
+}
+function tryChainByEvmChainId(evmChainId) {
+  return BY_EVM_CHAIN_ID.get(evmChainId);
+}
+function chainByDomain(domain, network) {
+  const chain = BY_DOMAIN_AND_NETWORK.get(`${domain}:${network}`);
+  if (!chain) {
+    throw new UnknownChainError(`domain=${domain} network=${network}`);
+  }
+  return chain;
+}
+function explorerTxUrl(chain, txHash) {
+  return `${chain.explorerUrl}/tx/${txHash}${chain.explorerQuery ?? ""}`;
+}
+function explorerAddressUrl(chain, address) {
+  return `${chain.explorerUrl}/${addressPath(chain, address)}/${address}${chain.explorerQuery ?? ""}`;
+}
+function addressPath(chain, address) {
+  switch (chain.ecosystem) {
+    case "starknet":
+      return "contract";
+    case "stellar":
+      return address.startsWith("C") ? "contract" : "account";
+    default:
+      return "address";
+  }
+}
+
+// src/chains/attestation.ts
+var s = (min, max = min) => ({ min, max });
+var L1_FINALITY = s(900, 1140);
+var BY_DOMAIN = {
+  0: { fast: s(20), standard: L1_FINALITY },
+  1: { standard: s(8) },
+  2: { fast: s(8), standard: L1_FINALITY },
+  3: { fast: s(8), standard: L1_FINALITY },
+  5: { fast: s(8), standard: s(25) },
+  6: { fast: s(8), standard: L1_FINALITY },
+  7: { standard: s(8) },
+  10: { fast: s(8), standard: L1_FINALITY },
+  11: { fast: s(8), standard: s(21600, 115200) },
+  12: { fast: s(8), standard: L1_FINALITY },
+  13: { standard: s(8) },
+  14: { fast: s(8), standard: L1_FINALITY },
+  15: { standard: s(5) },
+  16: { standard: s(5) },
+  18: { standard: s(10) },
+  19: { standard: s(5) },
+  21: { fast: s(8), standard: s(1800) },
+  22: { fast: s(8), standard: L1_FINALITY },
+  25: { fast: s(20), standard: s(7200, 14400) },
+  26: { standard: s(0.5) },
+  27: { standard: s(5) },
+  28: { fast: s(8), standard: s(960, 1260) },
+  29: { standard: s(0.65) },
+  30: { fast: s(8), standard: s(1200, 1800) },
+  31: { standard: s(7) },
+  32: { standard: s(0.5) },
+  33: { standard: s(1) },
+  37: { fast: s(8), standard: L1_FINALITY }
+};
+function attestationSeconds(chain, speed) {
+  const times = BY_DOMAIN[chain.cctpDomain]?.[speed];
+  if (!times) {
+    throw new ProtocolError(
+      "no_route",
+      `No ${speed} attestation time for ${chain.label}.`
+    );
+  }
+  return times;
+}
+
+// src/abi/tokenMessengerV2.ts
+var tokenMessengerV2Abi = [
+  {
+    type: "function",
+    name: "depositForBurn",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "destinationDomain", type: "uint32" },
+      { name: "mintRecipient", type: "bytes32" },
+      { name: "burnToken", type: "address" },
+      { name: "destinationCaller", type: "bytes32" },
+      { name: "maxFee", type: "uint256" },
+      { name: "minFinalityThreshold", type: "uint32" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "depositForBurnWithHook",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "destinationDomain", type: "uint32" },
+      { name: "mintRecipient", type: "bytes32" },
+      { name: "burnToken", type: "address" },
+      { name: "destinationCaller", type: "bytes32" },
+      { name: "maxFee", type: "uint256" },
+      { name: "minFinalityThreshold", type: "uint32" },
+      { name: "hookData", type: "bytes" }
+    ],
+    outputs: []
+  },
+  {
+    type: "event",
+    name: "DepositForBurn",
+    anonymous: false,
+    inputs: [
+      { name: "burnToken", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "depositor", type: "address", indexed: true },
+      { name: "mintRecipient", type: "bytes32", indexed: false },
+      { name: "destinationDomain", type: "uint32", indexed: false },
+      { name: "destinationTokenMessenger", type: "bytes32", indexed: false },
+      { name: "destinationCaller", type: "bytes32", indexed: false },
+      { name: "maxFee", type: "uint256", indexed: false },
+      { name: "minFinalityThreshold", type: "uint32", indexed: false },
+      { name: "hookData", type: "bytes", indexed: false }
+    ]
+  }
+];
+
+// src/abi/messageTransmitterV2.ts
+var messageTransmitterV2Abi = [
+  {
+    type: "function",
+    name: "receiveMessage",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "message", type: "bytes" },
+      { name: "attestation", type: "bytes" }
+    ],
+    outputs: [{ name: "success", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "usedNonces",
+    stateMutability: "view",
+    inputs: [{ name: "nonce", type: "bytes32" }],
+    outputs: [{ name: "isUsed", type: "uint256" }]
+  },
+  {
+    type: "event",
+    name: "MessageReceived",
+    anonymous: false,
+    inputs: [
+      { name: "caller", type: "address", indexed: true },
+      { name: "sourceDomain", type: "uint32", indexed: true },
+      { name: "nonce", type: "bytes32", indexed: true },
+      { name: "sender", type: "bytes32", indexed: false },
+      { name: "finalityThresholdExecuted", type: "uint32", indexed: false },
+      { name: "messageBody", type: "bytes", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "MessageSent",
+    anonymous: false,
+    inputs: [{ name: "message", type: "bytes", indexed: false }]
+  }
+];
+
+// src/abi/usdc.ts
+var usdcAbi = [
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "balance", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "remaining", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "value", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "transfer",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "nonces",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "DOMAIN_SEPARATOR",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32" }]
+  },
+  {
+    type: "function",
+    name: "permit",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "deadline", type: "uint256" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    anonymous: false,
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Approval",
+    anonymous: false,
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ]
+  }
+];
+
+// src/abi/tokenMessengerWithFees.ts
+var tokenMessengerWithFeesAbi = [
+  {
+    type: "function",
+    name: "depositForBurnWithFees",
+    stateMutability: "payable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "destinationDomain", type: "uint32" },
+      { name: "mintRecipient", type: "bytes32" },
+      { name: "burnToken", type: "address" },
+      { name: "destinationCaller", type: "bytes32" },
+      {
+        name: "claim",
+        type: "tuple",
+        components: [
+          { name: "signedQuote", type: "bytes" },
+          { name: "refundAddress", type: "address" }
+        ]
+      }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "getFee",
+    stateMutability: "pure",
+    inputs: [{ name: "signedQuote", type: "bytes" }],
+    outputs: [
+      { name: "totalFee", type: "uint256" },
+      { name: "feeToken", type: "address" }
+    ]
+  },
+  {
+    type: "function",
+    name: "tokenMessenger",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+
+// src/iris/urls.ts
+var IRIS_MAINNET_URL = "https://iris-api.circle.com";
+var IRIS_SANDBOX_URL = "https://iris-api-sandbox.circle.com";
+function irisBaseUrl(network) {
+  return network === "mainnet" ? IRIS_MAINNET_URL : IRIS_SANDBOX_URL;
+}
+
+// src/iris/limiter.ts
+function createIrisLimiter(options = {}) {
+  const rate = options.ratePerSecond ?? 30;
+  const standDownMs = options.standDownMs ?? 5 * 6e4;
+  const now = options.now ?? (() => Date.now());
+  const sleep3 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const buckets = /* @__PURE__ */ new Map();
+  const bucket = (host) => {
+    let b = buckets.get(host);
+    if (!b) {
+      b = { tokens: rate, updatedAt: now(), blockedUntil: 0 };
+      buckets.set(host, b);
+    }
+    return b;
+  };
+  return {
+    async acquire(host) {
+      const b = bucket(host);
+      if (now() < b.blockedUntil) {
+        throw new IrisRateLimitedError(host, b.blockedUntil);
+      }
+      const elapsed = (now() - b.updatedAt) / 1e3;
+      b.tokens = Math.min(rate, b.tokens + elapsed * rate);
+      b.updatedAt = now();
+      if (b.tokens < 1) {
+        const waitMs = Math.ceil((1 - b.tokens) / rate * 1e3);
+        await sleep3(waitMs);
+        b.tokens += waitMs / 1e3 * rate;
+        b.updatedAt = now();
+      }
+      b.tokens -= 1;
+    },
+    standDown(host) {
+      const b = bucket(host);
+      b.blockedUntil = now() + standDownMs;
+      return b.blockedUntil;
+    },
+    now,
+    sleep: sleep3
+  };
+}
+var defaultIrisLimiter = createIrisLimiter();
+
+// src/iris/fetch.ts
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_BASE_DELAY_MS = 300;
+async function fetchIrisJson(url, options = {}, request = {
+  method: "GET"
+}) {
+  const {
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    maxRetries = DEFAULT_MAX_RETRIES,
+    baseDelayMs = DEFAULT_BASE_DELAY_MS,
+    signal,
+    fetch: fetchImpl = fetch,
+    limiter = defaultIrisLimiter
+  } = options;
+  const host = new URL(url).host;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (signal?.aborted) throw new IrisAbortedError("Aborted by caller");
+    await limiter.acquire(host);
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    const onCallerAbort = () => ctrl.abort();
+    signal?.addEventListener("abort", onCallerAbort);
+    try {
+      const res = await fetchImpl(url, {
+        method: request.method,
+        headers: {
+          accept: "application/json",
+          ...request.method === "POST" && {
+            "content-type": "application/json"
+          }
+        },
+        ...request.method === "POST" && {
+          body: JSON.stringify(request.body)
+        },
+        signal: ctrl.signal
+      });
+      if (res.ok) {
+        let json;
+        try {
+          json = await res.json();
+        } catch (err) {
+          throw new IrisParseError(`Invalid JSON from ${url}`, err);
+        }
+        return json;
+      }
+      if (res.status === 429) {
+        throw new IrisRateLimitedError(host, limiter.standDown(host));
+      }
+      if (res.status >= 400 && res.status < 500 && res.status !== 429) {
+        throw new IrisHttpError(res.status, url, await safeText(res));
+      }
+      lastError = new IrisHttpError(res.status, url, await safeText(res));
+    } catch (err) {
+      if (err instanceof IrisParseError) throw err;
+      if (err instanceof IrisRateLimitedError) throw err;
+      if (err instanceof IrisHttpError) {
+        if (err.status < 500 && err.status !== 429) throw err;
+      }
+      if (signal?.aborted) throw new IrisAbortedError("Aborted by caller");
+      lastError = err;
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onCallerAbort);
+    }
+    if (attempt < maxRetries) {
+      await sleep(baseDelayMs * (attempt + 1), signal);
+    }
+  }
+  if (lastError instanceof IrisHttpError) throw lastError;
+  throw new IrisNetworkError(
+    `Iris request failed after ${maxRetries + 1} attempts`,
+    lastError
+  );
+}
+async function safeText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new IrisAbortedError("Aborted by caller"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(new IrisAbortedError("Aborted by caller"));
+    }
+    signal?.addEventListener("abort", onAbort);
+  });
+}
+
+// src/iris/types.ts
+var FINALITY_FAST = 1e3;
+var FINALITY_STANDARD = 2e3;
+
+// src/fees/math.ts
+var CENTI_BPS_PER_UNIT = 1000000n;
+var DECIMAL = /^(\d+)(?:\.(\d+))?$/;
+function ceilDecimal(raw, decimals, what) {
+  const text = typeof raw === "number" ? String(raw) : typeof raw === "string" ? raw : "";
+  const match = DECIMAL.exec(text);
+  if (!match) {
+    throw new IrisParseError(`Iris ${what} is invalid: ${String(raw)}`);
+  }
+  const fraction = match[2] ?? "";
+  const kept = fraction.slice(0, decimals).padEnd(decimals, "0");
+  const dropped = /[1-9]/.test(fraction.slice(decimals)) ? 1n : 0n;
+  return BigInt((match[1] ?? "0") + kept) + dropped;
+}
+function parseFeeBps(raw) {
+  return ceilDecimal(raw, 2, "minimumFee");
+}
+function parseForwarderFee(raw) {
+  return ceilDecimal(raw, 0, "forwardFee");
+}
+function computeBurnFee(amount, feeCentiBps) {
+  if (amount < 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `amount must be non-negative, got ${amount}`
+    );
+  }
+  if (feeCentiBps < 0n) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `feeCentiBps must be non-negative, got ${feeCentiBps}`
+    );
+  }
+  return ceilDiv(amount * feeCentiBps, CENTI_BPS_PER_UNIT);
+}
+function selectForwarderFee(tier, level = "med") {
+  if (!tier.forwardFee) {
+    throw new ProtocolError(
+      "fee_unavailable",
+      "Tier has no forwardFee. Fetch burn fees with includeForwarderFee=true"
+    );
+  }
+  const value = tier.forwardFee[level];
+  if (value < 0n) {
+    throw new ProtocolError(
+      "fee_unavailable",
+      `Invalid forwardFee.${level}: ${value}`
+    );
+  }
+  return value;
+}
+function computeMaxFee(input) {
+  const {
+    amount,
+    tier,
+    forwarderLevel = "med",
+    forwarderBufferBps = 0,
+    includeForwarder = true,
+    burnFeeBufferBps = 0,
+    minBurnFee = 0n
+  } = input;
+  const irisFee = computeBurnFee(amount, tier.minimumFee);
+  const burnFee = irisFee > minBurnFee ? irisFee : minBurnFee;
+  const forwarderFee = includeForwarder ? applyBufferBps(
+    selectForwarderFee(tier, forwarderLevel),
+    forwarderBufferBps
+  ) : 0n;
+  return {
+    burnFee,
+    forwarderFee,
+    maxFee: applyBufferBps(burnFee, burnFeeBufferBps) + forwarderFee
+  };
+}
+function applyBufferBps(value, bps) {
+  if (!Number.isSafeInteger(bps) || bps < 0) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `bufferBps must be a non-negative whole number, got ${bps}`
+    );
+  }
+  return ceilDiv(value * (10000n + BigInt(bps)), 10000n);
+}
+function ceilDiv(numerator, denominator) {
+  return (numerator + denominator - 1n) / denominator;
+}
+
+// src/iris/fees.ts
+async function getBurnFees(network, sourceDomain, destinationDomain, options = {}) {
+  const { includeForwarderFee = true, ...fetchOpts } = options;
+  const base = irisBaseUrl(network);
+  const url = new URL(
+    `${base}/v2/burn/USDC/fees/${sourceDomain}/${destinationDomain}`
+  );
+  if (includeForwarderFee) url.searchParams.set("forward", "true");
+  const raw = await fetchIrisJson(url.toString(), fetchOpts);
+  if (!Array.isArray(raw)) {
+    throw new IrisParseError("Iris burn-fees response is not an array");
+  }
+  return raw.map((row) => normalizeTier(row)).filter((t) => t !== null);
+}
+function normalizeTier(row) {
+  if (!row || typeof row !== "object") {
+    throw new IrisParseError("Iris fee tier is not an object");
+  }
+  const r = row;
+  const threshold = r.finalityThreshold;
+  if (threshold !== FINALITY_FAST && threshold !== FINALITY_STANDARD) {
+    return null;
+  }
+  const out = {
+    finalityThreshold: threshold,
+    minimumFee: parseFeeBps(r.minimumFee)
+  };
+  if (r.forwardFee && typeof r.forwardFee === "object") {
+    const ff = r.forwardFee;
+    out.forwardFee = {
+      low: parseForwarderFee(ff.low),
+      med: parseForwarderFee(ff.med),
+      high: parseForwarderFee(ff.high)
+    };
+  }
+  return out;
+}
+function pickFeeTier(tiers, speed) {
+  const threshold = speed === "fast" ? FINALITY_FAST : FINALITY_STANDARD;
+  const tier = tiers.find((t) => t.finalityThreshold === threshold);
+  if (!tier) {
+    throw new ProtocolError(
+      "tier_not_found",
+      `Iris returned no ${speed === "fast" ? "Fast" : "Standard"} Transfer fee for this route.`
+    );
+  }
+  return tier;
+}
+function pickForwarderFee(tier, level = "med") {
+  return selectForwarderFee(tier, level);
+}
+
+// src/iris/messages.ts
+async function getMessages(query, options) {
+  const { network, baseUrl, ...fetchOpts } = options;
+  const base = (baseUrl ?? irisBaseUrl(network)).replace(/\/+$/, "");
+  const url = new URL(`${base}/v2/messages/${query.sourceDomain}`);
+  if (query.transactionHash) {
+    url.searchParams.set("transactionHash", query.transactionHash);
+  }
+  if (query.nonce) {
+    url.searchParams.set("nonce", query.nonce);
+  }
+  try {
+    const json = await fetchIrisJson(
+      url.toString(),
+      fetchOpts
+    );
+    return json.messages ?? [];
+  } catch (err) {
+    if (err instanceof IrisHttpError && err.status === 404) {
+      return [];
+    }
+    throw err;
+  }
+}
+var DEFAULT_INTERVAL_MS = 3e3;
+var DEFAULT_TIMEOUT_MS2 = 15 * 60 * 1e3;
+var TIMEOUT_MARGIN_MS = 5 * 60 * 1e3;
+function pollBudget(eta) {
+  const intervalMs = eta.max <= 60 ? 2e3 : eta.max <= 30 * 60 ? 1e4 : 3e4;
+  return { intervalMs, timeoutMs: eta.max * 2 * 1e3 + TIMEOUT_MARGIN_MS };
+}
+function isForwardDone(message) {
+  return (message.forwardState === "CONFIRMED" || message.forwardState === "COMPLETE") && !!message.forwardTxHash;
+}
+function defaultIsDone(message) {
+  if (message.forwardState != null) {
+    return isForwardDone(message) || message.forwardState === "FAILED";
+  }
+  return message.status === "complete";
+}
+async function pollMessages(query, options) {
+  const {
+    intervalMs = DEFAULT_INTERVAL_MS,
+    timeoutMs = DEFAULT_TIMEOUT_MS2,
+    isDone = defaultIsDone,
+    onRateLimited,
+    signal,
+    ...rest
+  } = options;
+  const limiter = rest.limiter ?? defaultIrisLimiter;
+  let deadline = limiter.now() + timeoutMs;
+  let latest = null;
+  while (limiter.now() < deadline) {
+    if (signal?.aborted) throw new IrisAbortedError("Aborted by caller");
+    let messages;
+    try {
+      messages = await getMessages(query, { ...rest, signal });
+    } catch (err) {
+      if (!(err instanceof IrisRateLimitedError)) throw err;
+      onRateLimited?.(err.retryAt);
+      const waitMs = Math.max(0, err.retryAt - limiter.now());
+      deadline += waitMs;
+      await limiter.sleep(waitMs);
+      continue;
+    }
+    if (messages.length > 0) {
+      const first = messages[0];
+      if (first) {
+        latest = first;
+        if (isDone(first)) return first;
+      }
+    }
+    await sleep2(intervalMs, signal);
+  }
+  return latest;
+}
+function sleep2(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new IrisAbortedError("Aborted by caller"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(new IrisAbortedError("Aborted by caller"));
+    }
+    signal?.addEventListener("abort", onAbort);
+  });
+}
+
+// src/iris/reattest.ts
+async function reattest(nonce, options) {
+  const { network, ...fetchOpts } = options;
+  const url = `${irisBaseUrl(network)}/v2/reattest/${nonce}`;
+  let json;
+  try {
+    json = await fetchIrisJson(url, fetchOpts, {
+      method: "POST",
+      body: {}
+    });
+  } catch (err) {
+    if (err instanceof IrisHttpError && err.status === 404) return null;
+    throw err;
+  }
+  const acknowledged = typeof json === "object" && json !== null && "nonce" in json ? json.nonce : void 0;
+  if (typeof acknowledged !== "string") {
+    throw new IrisParseError("Iris reattest reply has no nonce");
+  }
+  return { nonce: acknowledged };
+}
+
+// src/iris/quote.ts
+async function getSignedBurnQuote(network, sourceDomain, destinationDomain, request, options = {}) {
+  const url = `${irisBaseUrl(network)}/v2/quote/burn/usdc/${sourceDomain}/${destinationDomain}`;
+  const raw = await fetchIrisJson(url, options, {
+    method: "POST",
+    body: {
+      amount: request.amount.toString(),
+      feeToken: request.feeToken,
+      requests: request.requests.map((type) => ({ type }))
+    }
+  });
+  const quote = parseQuote(raw);
+  if (quote.burnAmount !== void 0 && quote.burnAmount !== request.amount) {
+    throw new IrisParseError(
+      `Iris quoted ${quote.burnAmount} subunits, not the ${request.amount} requested`
+    );
+  }
+  if (quote.feeToken.toLowerCase() !== request.feeToken.toLowerCase()) {
+    throw new IrisParseError(
+      `Iris priced the fee in ${quote.feeToken}, not ${request.feeToken}`
+    );
+  }
+  const types = quote.items.map((i) => i.type).sort();
+  if (types.join() !== [...request.requests].sort().join()) {
+    throw new IrisParseError(
+      `Iris priced ${types.join(", ")}, not ${request.requests.join(", ")}`
+    );
+  }
+  return quote;
+}
+function parseQuote(raw) {
+  const fail = (what) => {
+    throw new IrisParseError(`Iris quote: ${what}`);
+  };
+  if (typeof raw !== "object" || raw === null) return fail("not an object");
+  const r = raw;
+  const signedQuote = r.signedQuote;
+  if (typeof signedQuote !== "string" || !/^0x([0-9a-fA-F]{2})+$/.test(signedQuote)) {
+    return fail("signedQuote is not hex bytes");
+  }
+  if (!Number.isSafeInteger(r.issuedAt))
+    return fail("issuedAt is not a timestamp");
+  const feeToken = r.feeToken;
+  if (typeof feeToken !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(feeToken)) {
+    return fail("feeToken is not an address");
+  }
+  const feeTotalAmount = subunits(r.feeTotalAmount) ?? fail("feeTotalAmount");
+  const burnAmount = r.burnAmount === void 0 ? void 0 : subunits(r.burnAmount) ?? fail("burnAmount");
+  if (!Array.isArray(r.items) || r.items.length === 0) return fail("no items");
+  const items = r.items.map(
+    (item) => {
+      const i = item ?? {};
+      if (i.type !== "FORWARD" && i.type !== "PRE_FINALITY") {
+        return fail(`unknown item type ${String(i.type)}`);
+      }
+      return {
+        type: i.type,
+        amount: subunits(i.amount) ?? fail("item amount")
+      };
+    }
+  );
+  if (items.reduce((sum, i) => sum + i.amount, 0n) !== feeTotalAmount) {
+    return fail("items do not add up to feeTotalAmount");
+  }
+  return {
+    signedQuote,
+    issuedAt: r.issuedAt,
+    expiry: parseExpiry(r.expiry) ?? fail("expiry"),
+    feeTotalAmount,
+    feeToken,
+    ...burnAmount !== void 0 && { burnAmount },
+    items
+  };
+}
+function parseExpiry(raw) {
+  if (typeof raw !== "object" || raw === null) return void 0;
+  const e = raw;
+  if (e.mode === "TIMESTAMP" && Number.isSafeInteger(e.expiresAt)) {
+    return { mode: "TIMESTAMP", expiresAt: e.expiresAt };
+  }
+  if (e.mode === "BLOCK_NUMBER" && Number.isSafeInteger(e.expiresAtBlock)) {
+    return {
+      mode: "BLOCK_NUMBER",
+      expiresAtBlock: BigInt(e.expiresAtBlock)
+    };
+  }
+  return void 0;
+}
+function subunits(raw) {
+  return typeof raw === "string" && /^(0|[1-9]\d*)$/.test(raw) ? BigInt(raw) : void 0;
+}
+async function getFastBurnAllowance(network, options = {}) {
+  const raw = await fetchIrisJson(
+    `${irisBaseUrl(network)}/v2/fastBurn/USDC/allowance`,
+    options
+  );
+  const value = typeof raw === "object" && raw !== null && "allowance" in raw ? raw.allowance : void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new IrisParseError("Iris allowance is not a non-negative number");
+  }
+  const match = /^(\d+)(?:\.(\d+))?$/.exec(String(value));
+  if (!match)
+    throw new IrisParseError(`Iris allowance ${value} is not decimal`);
+  const frac = (match[2] ?? "").padEnd(6, "0").slice(0, 6);
+  return BigInt(match[1]) * 1000000n + BigInt(frac);
+}
+
+// src/rpc/jsonRpc.ts
+async function callRpc(chain, method, params, parse, options = {}, parseError) {
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const body = JSON.stringify({ jsonrpc: "2.0", id: 1, method, params });
+  const urls = [...options.rpcUrls ?? [], ...chain.defaultRpcUrls];
+  const failures = [];
+  for (let i = 0, behind = 0; i < urls.length; i++) {
+    const url = urls[i];
+    try {
+      const res = await doFetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body
+      });
+      if (!res.ok) {
+        failures.push(`${url}: HTTP ${res.status}`);
+        continue;
+      }
+      const payload = await res.json();
+      const result = typeof payload === "object" && payload !== null && "result" in payload ? parse(payload.result) : void 0;
+      if (result !== void 0) return result;
+      const answer = parseError?.(errorCode(payload));
+      if (answer !== void 0) return answer;
+      failures.push(`${url}: ${JSON.stringify(payload)}`);
+      if (errorCode(payload) === LAGGING_BACKEND && behind < LAG_RETRIES) {
+        behind += 1;
+        await new Promise((resolve) => setTimeout(resolve, 250 * behind));
+        i -= 1;
+        continue;
+      }
+      behind = 0;
+    } catch (err) {
+      failures.push(
+        `${url}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  throw new ProtocolError(
+    "rpc_unavailable",
+    `${method} on ${chain.id} failed: ${failures.join("; ")}`
+  );
+}
+var LAGGING_BACKEND = -32014;
+var LAG_RETRIES = 3;
+function errorCode(payload) {
+  if (typeof payload !== "object" || payload === null) return void 0;
+  const error = payload.error;
+  return error?.code;
+}
+async function getGasPrice(chain, options = {}) {
+  return callRpc(
+    chain,
+    "eth_gasPrice",
+    [],
+    (r) => typeof r === "string" && /^0x[0-9a-fA-F]+$/.test(r) ? BigInt(r) : void 0,
+    options
+  );
+}
+async function getBlockNumber(chain, options = {}) {
+  return callRpc(
+    chain,
+    "eth_blockNumber",
+    [],
+    (r) => typeof r === "string" && /^0x[0-9a-fA-F]+$/.test(r) ? BigInt(r) : void 0,
+    options
+  );
+}
+var USED_NONCES = "0xfeb61724";
+async function isNonceUsed(chain, nonce, options = {}) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(nonce)) {
+    throw new ProtocolError("rpc_unavailable", `nonce ${nonce} is not bytes32`);
+  }
+  return callRpc(
+    chain,
+    "eth_call",
+    [
+      { to: chain.messageTransmitter, data: `${USED_NONCES}${nonce.slice(2)}` },
+      "latest"
+    ],
+    (r) => typeof r === "string" && /^0x[0-9a-fA-F]{64}$/.test(r) ? BigInt(r) !== 0n : void 0,
+    options
+  );
+}
+async function getTransactionStatus(chain, hash2, options = {}) {
+  return callRpc(
+    chain,
+    "eth_getTransactionReceipt",
+    [hash2],
+    (r) => {
+      if (r === null) return "unknown";
+      if (typeof r !== "object") return void 0;
+      const status = r.status;
+      if (status === "0x1") return "success";
+      if (status === "0x0") return "reverted";
+      return void 0;
+    },
+    options
+  );
+}
+var BALANCE_OF = "0x70a08231";
+async function getUsdcBalance(chain, owner, options = {}) {
+  if (!/^0x[0-9a-fA-F]{40}$/.test(owner)) {
+    throw new ProtocolError("rpc_unavailable", `${owner} is not an address`);
+  }
+  return callRpc(
+    chain,
+    "eth_call",
+    [
+      {
+        to: chain.usdc,
+        data: `${BALANCE_OF}${owner.slice(2).padStart(64, "0")}`
+      },
+      "latest"
+    ],
+    (r) => typeof r === "string" && /^0x[0-9a-fA-F]{64}$/.test(r) ? BigInt(r) : void 0,
+    options
+  );
+}
+var IS_NONCE_USED_SELECTOR = starknet.hash.getSelectorFromName("is_nonce_used");
+function bytes32(nonce) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(nonce)) {
+    throw new ProtocolError("rpc_unavailable", `nonce ${nonce} is not bytes32`);
+  }
+  return nonce.slice(2).toLowerCase();
+}
+async function isStarknetNonceUsed(chain, nonce, options = {}) {
+  const hex = bytes32(nonce);
+  return callRpc(
+    chain,
+    "starknet_call",
+    {
+      request: {
+        contract_address: chain.messageTransmitter,
+        entry_point_selector: IS_NONCE_USED_SELECTOR,
+        // A u256 goes over the wire as its low then high 128 bits.
+        calldata: [`0x${hex.slice(32)}`, `0x${hex.slice(0, 32)}`]
+      },
+      // Public Starknet RPCs reject the "pending" tag starknet.js defaults to.
+      block_id: "latest"
+    },
+    (r) => Array.isArray(r) && (r[0] === "0x0" || r[0] === "0x1") ? r[0] === "0x1" : void 0,
+    options
+  );
+}
+async function isStellarNonceUsed(chain, nonce, options = {}) {
+  const tx = new stellarSdk.TransactionBuilder(new stellarSdk.Account(chain.usdcIssuer, "0"), {
+    fee: stellarSdk.BASE_FEE,
+    networkPassphrase: chain.networkPassphrase
+  }).addOperation(
+    new stellarSdk.Contract(chain.messageTransmitter).call(
+      "is_nonce_used",
+      stellarSdk.nativeToScVal(Buffer.from(bytes32(nonce), "hex"), { type: "bytes" })
+    )
+  ).setTimeout(30).build();
+  return callRpc(
+    chain,
+    "simulateTransaction",
+    { transaction: tx.toXDR() },
+    (r) => {
+      const results = r?.results;
+      const value = results?.[0]?.xdr;
+      if (typeof value !== "string") return void 0;
+      const used = stellarSdk.scValToNative(stellarSdk.xdr.ScVal.fromXDR(value, "base64"));
+      return typeof used === "boolean" ? used : void 0;
+    },
+    options
+  );
+}
+
+// src/rpc/starknetClass.ts
+var CONTRACT_NOT_FOUND = 20;
+var FELT = /^0x[0-9a-fA-F]{1,64}$/;
+async function getStarknetClassHashAt(chain, address, options = {}) {
+  return callRpc(
+    chain,
+    "starknet_getClassHashAt",
+    { block_id: "latest", contract_address: address },
+    (r) => typeof r === "string" && FELT.test(r) ? r : void 0,
+    options,
+    (code) => code === CONTRACT_NOT_FOUND ? null : void 0
+  );
+}
+
+// src/rpc/starknetTx.ts
+var TXN_HASH_NOT_FOUND = 29;
+var ACCEPTED = /* @__PURE__ */ new Set(["ACCEPTED_ON_L2", "ACCEPTED_ON_L1"]);
+var NOT_YET = /* @__PURE__ */ new Set(["RECEIVED", "CANDIDATE", "PRE_CONFIRMED"]);
+async function getStarknetTransactionStatus(chain, hash2, options = {}) {
+  return callRpc(
+    chain,
+    "starknet_getTransactionReceipt",
+    { transaction_hash: hash2 },
+    (r) => {
+      if (typeof r !== "object" || r === null) return void 0;
+      const { finality_status, execution_status, block_number } = r;
+      if (typeof finality_status !== "string") return void 0;
+      if (NOT_YET.has(finality_status)) return { state: "pending" };
+      if (!ACCEPTED.has(finality_status)) return void 0;
+      if (typeof block_number !== "number") return void 0;
+      if (execution_status === "SUCCEEDED") {
+        return { state: "success", blockNumber: block_number };
+      }
+      if (execution_status === "REVERTED") {
+        return { state: "reverted", blockNumber: block_number };
+      }
+      return void 0;
+    },
+    options,
+    (code) => code === TXN_HASH_NOT_FOUND ? { state: "pending" } : void 0
+  );
+}
+
+// src/forwarder/hookData.ts
+var CCTP_FORWARD_HOOK_DATA = "0x636374702d666f72776172640000000000000000000000000000000000000000";
+var CCTP_FORWARD_HOOK_DATA_LENGTH = 32;
+var MAGIC_PREFIX = "cctp-forward";
+var VERSION = 0;
+var PAYLOAD_LENGTH = 0;
+function buildForwarderHookData() {
+  const buf = new Uint8Array(CCTP_FORWARD_HOOK_DATA_LENGTH);
+  const encoder = new TextEncoder();
+  buf.set(encoder.encode(MAGIC_PREFIX), 0);
+  const view = new DataView(buf.buffer);
+  view.setUint32(24, VERSION, false);
+  view.setUint32(28, PAYLOAD_LENGTH, false);
+  return bytesToHex(buf);
+}
+function isForwarderHookData(hex) {
+  if (!hex.startsWith("0x")) return false;
+  return hex.toLowerCase().startsWith(
+    "0x636374702d666f72776172640000000000000000000000000000000000000000"
+  );
+}
+var ANY_DESTINATION_CALLER = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function bytesToHex(bytes) {
+  let out = "0x";
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i];
+    if (byte === void 0) continue;
+    out += byte.toString(16).padStart(2, "0");
+  }
+  return out;
+}
+
+// src/encoding/address.ts
+var ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/;
+var InvalidAddressError = class extends InvalidInputError {
+  constructor(input) {
+    super("invalid_address", `Invalid EVM address: ${input}`);
+    this.name = "InvalidAddressError";
+  }
+};
+var InvalidBytes32Error = class extends InvalidInputError {
+  constructor(input) {
+    super("invalid_bytes32", `Invalid bytes32 value: ${input}`);
+    this.name = "InvalidBytes32Error";
+  }
+};
+function toBytes32(address) {
+  if (!ADDRESS_REGEX.test(address)) {
+    throw new InvalidAddressError(address);
+  }
+  const hex = address.slice(2).toLowerCase();
+  return `0x${"00".repeat(12)}${hex}`;
+}
+function fromBytes32(value) {
+  const cleaned = value.toLowerCase();
+  if (!/^0x[0-9a-f]{64}$/.test(cleaned)) {
+    throw new InvalidBytes32Error(value);
+  }
+  const upper = cleaned.slice(2, 2 + 24);
+  if (upper !== "00".repeat(12)) {
+    throw new InvalidBytes32Error(
+      `non-zero upper 12 bytes (not an EVM address): ${value}`
+    );
+  }
+  return `0x${cleaned.slice(26)}`;
+}
+function tryFromBytes32(value) {
+  try {
+    return fromBytes32(value);
+  } catch {
+    return void 0;
+  }
+}
+function isAddress(value) {
+  return ADDRESS_REGEX.test(value);
+}
+
+// src/fees/minFee.ts
+var GET_MIN_FEE_AMOUNT = "0x516990e3";
+async function getStandardMinFee(chain, amount, options = {}) {
+  if (!chain.capabilities.standardFeeSwitch) {
+    throw new InvalidInputError(
+      "invalid_chain",
+      `${chain.id} has no getMinFeeAmount; its TokenMessengerV2 reverts the call`
+    );
+  }
+  if (amount < 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `amount must be non-negative, got ${amount}`
+    );
+  }
+  return callRpc(
+    chain,
+    "eth_call",
+    [
+      {
+        to: chain.tokenMessenger,
+        data: `${GET_MIN_FEE_AMOUNT}${amount.toString(16).padStart(64, "0")}`
+      },
+      "latest"
+    ],
+    (r) => typeof r === "string" && /^0x[0-9a-fA-F]{64}$/.test(r) ? BigInt(r) : void 0,
+    options
+  );
+}
+
+// src/message/decode.ts
+var HEADER_BYTES = 148;
+var BODY_BYTES = 228;
+function decodeBurnMessage(message) {
+  if (!/^0x([0-9a-fA-F]{2})*$/.test(message)) {
+    throw new InvalidInputError("invalid_input", "message is not hex bytes");
+  }
+  const hex = message.slice(2).toLowerCase();
+  if (hex.length < (HEADER_BYTES + BODY_BYTES) * 2) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `a burn message is at least ${HEADER_BYTES + BODY_BYTES} bytes, got ${hex.length / 2}`
+    );
+  }
+  let at = 0;
+  const take = (bytes) => {
+    const part = hex.slice(at, at + bytes * 2);
+    at += bytes * 2;
+    return part;
+  };
+  const uint = (bytes) => BigInt(`0x${take(bytes)}`);
+  const word = () => `0x${take(32)}`;
+  const small = (bytes) => Number.parseInt(take(bytes), 16);
+  return {
+    version: small(4),
+    sourceDomain: small(4),
+    destinationDomain: small(4),
+    nonce: word(),
+    sender: word(),
+    recipient: word(),
+    destinationCaller: word(),
+    minFinalityThreshold: small(4),
+    finalityThresholdExecuted: small(4),
+    body: {
+      version: small(4),
+      burnToken: word(),
+      mintRecipient: word(),
+      amount: uint(32),
+      messageSender: word(),
+      maxFee: uint(32),
+      feeExecuted: uint(32),
+      expirationBlock: uint(32),
+      hookData: `0x${hex.slice(at)}`
+    }
+  };
+}
+function encodeMintRecipient(destination, mintRecipient) {
+  if (destination.ecosystem === "solana") {
+    try {
+      new web3_js.PublicKey(mintRecipient);
+    } catch {
+      throw new InvalidInputError(
+        "invalid_address",
+        `mintRecipient is not a valid Solana pubkey: ${mintRecipient}`
+      );
+    }
+  } else if (destination.ecosystem === "stellar") {
+    if (!/^0x[a-fA-F0-9]{64}$/.test(mintRecipient)) {
+      throw new InvalidInputError(
+        "invalid_address",
+        `mintRecipient for Stellar must be 0x-prefixed 32-byte hex (the CctpForwarder strkey decoded); got: ${mintRecipient}`
+      );
+    }
+  } else if (destination.ecosystem === "starknet") {
+    if (!/^0x[a-fA-F0-9]{64}$/.test(mintRecipient)) {
+      throw new InvalidInputError(
+        "invalid_address",
+        `mintRecipient for Starknet must be 0x-prefixed 32-byte hex; got: ${mintRecipient}`
+      );
+    }
+  } else if (!isAddress(mintRecipient)) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `mintRecipient is not a valid EVM address: ${mintRecipient}`
+    );
+  }
+  if (destination.ecosystem === "solana") {
+    const bytes = new web3_js.PublicKey(mintRecipient).toBytes();
+    let hex = "0x";
+    for (const b of bytes) hex += b.toString(16).padStart(2, "0");
+    return hex;
+  }
+  if (destination.ecosystem === "stellar" || destination.ecosystem === "starknet") {
+    return mintRecipient;
+  }
+  return toBytes32(mintRecipient);
+}
+
+// src/burn/build.ts
+var MAX_USDC_AMOUNT = 10000000n * 1000000n;
+function buildBurnIntent(input) {
+  if (input.source.ecosystem !== "evm") {
+    throw new UnsupportedError(
+      "unsupported_ecosystem",
+      `Source chain "${input.source.id}" is not EVM. Use the Solana burn builder for Solana sources.`
+    );
+  }
+  if (input.source.cctpDomain === input.destination.cctpDomain) {
+    throw new InvalidInputError(
+      "no_route",
+      `Source and destination domains are identical (${input.source.cctpDomain}). Use a same-chain transfer instead of bridge.`
+    );
+  }
+  if (input.amount <= 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `amount must be positive, got ${input.amount}`
+    );
+  }
+  if (input.amount > MAX_USDC_AMOUNT) {
+    throw new ProtocolError(
+      "amount_too_large",
+      `amount exceeds CCTP per-burn cap of 10,000,000 USDC (got ${input.amount} subunits)`
+    );
+  }
+  const mintRecipientBytes32 = encodeMintRecipient(
+    input.destination,
+    input.mintRecipient
+  );
+  const finalityThreshold = input.fee.tier.finalityThreshold;
+  if (finalityThreshold === FINALITY_FAST && !input.source.capabilities.fastSource) {
+    throw new ProtocolError(
+      "no_route",
+      `Source chain "${input.source.id}" has no Fast Transfer. Use its Standard fee tier.`
+    );
+  }
+  const withForwarder = input.withForwarder ?? true;
+  const destinationCaller = input.destinationCaller ?? ANY_DESTINATION_CALLER;
+  const computed = computeMaxFee({
+    amount: input.amount,
+    tier: input.fee.tier,
+    ...input.fee.forwarderLevel !== void 0 && {
+      forwarderLevel: input.fee.forwarderLevel
+    },
+    ...input.fee.forwarderBufferBps !== void 0 && {
+      forwarderBufferBps: input.fee.forwarderBufferBps
+    },
+    includeForwarder: withForwarder
+  });
+  const { burnFee, forwarderFee } = computed;
+  const maxFee = input.fee.maxFee ?? computed.maxFee;
+  if (maxFee < 0n || maxFee >= input.amount) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `maxFee must be at least 0 and below amount (TokenMessengerV2 reverts otherwise), got ${maxFee}`
+    );
+  }
+  const calls = [];
+  if (!input.skipApprove) {
+    const approveAmount = input.approveAmount ?? input.amount;
+    if (approveAmount < input.amount) {
+      throw new InvalidInputError(
+        "invalid_amount",
+        `approveAmount (${approveAmount}) must be \u2265 amount (${input.amount})`
+      );
+    }
+    calls.push({
+      to: input.source.usdc,
+      data: viem.encodeFunctionData({
+        abi: usdcAbi,
+        functionName: "approve",
+        args: [input.source.tokenMessenger, approveAmount]
+      }),
+      value: 0n
+    });
+  }
+  const burnArgs = [
+    input.amount,
+    input.destination.cctpDomain,
+    mintRecipientBytes32,
+    input.source.usdc,
+    destinationCaller,
+    maxFee,
+    finalityThreshold
+  ];
+  const effectiveHookData = input.customHookData ?? CCTP_FORWARD_HOOK_DATA;
+  const callWithHook = withForwarder || input.customHookData !== void 0;
+  calls.push({
+    to: input.source.tokenMessenger,
+    data: callWithHook ? viem.encodeFunctionData({
+      abi: tokenMessengerV2Abi,
+      functionName: "depositForBurnWithHook",
+      args: [...burnArgs, effectiveHookData]
+    }) : viem.encodeFunctionData({
+      abi: tokenMessengerV2Abi,
+      functionName: "depositForBurn",
+      args: burnArgs
+    }),
+    value: 0n
+  });
+  return {
+    source: input.source,
+    destination: input.destination,
+    calls,
+    amount: input.amount,
+    maxFee,
+    burnFee,
+    forwarderFee,
+    mintRecipientBytes32,
+    withForwarder,
+    finalityThreshold
+  };
+}
+function buildBurnWithFeesIntent(input) {
+  const { source, destination } = input;
+  if (source.ecosystem !== "evm" || !source.tokenMessengerWithFees) {
+    throw new UnsupportedError(
+      "unsupported_chain",
+      `${source.id} has no TokenMessengerWithFees, so it cannot pay fees upfront`
+    );
+  }
+  if (destination.ecosystem === "stellar") {
+    throw new UnsupportedError(
+      "unsupported_chain",
+      "burns to Stellar carry custom hook data and cannot pay fees upfront"
+    );
+  }
+  if (source.cctpDomain === destination.cctpDomain) {
+    throw new InvalidInputError(
+      "no_route",
+      `Source and destination domains are identical (${source.cctpDomain})`
+    );
+  }
+  if (input.amount <= 0n || input.fee < 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `amount must be positive and fee non-negative, got ${input.amount} and ${input.fee}`
+    );
+  }
+  if (!isAddress(input.refundAddress)) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `refundAddress is not a valid EVM address: ${input.refundAddress}`
+    );
+  }
+  const mintRecipientBytes32 = encodeMintRecipient(
+    destination,
+    input.mintRecipient
+  );
+  const approveAmount = input.approveAmount ?? input.amount + input.fee;
+  if (approveAmount < input.amount + input.fee) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `approveAmount (${approveAmount}) must cover amount plus fee (${input.amount + input.fee})`
+    );
+  }
+  const calls = [
+    {
+      to: source.usdc,
+      data: viem.encodeFunctionData({
+        abi: usdcAbi,
+        functionName: "approve",
+        args: [source.tokenMessengerWithFees, approveAmount]
+      }),
+      value: 0n
+    },
+    {
+      to: source.tokenMessengerWithFees,
+      data: viem.encodeFunctionData({
+        abi: tokenMessengerWithFeesAbi,
+        functionName: "depositForBurnWithFees",
+        args: [
+          input.amount,
+          destination.cctpDomain,
+          mintRecipientBytes32,
+          source.usdc,
+          ANY_DESTINATION_CALLER,
+          {
+            signedQuote: input.signedQuote,
+            refundAddress: input.refundAddress
+          }
+        ]
+      }),
+      value: 0n
+    }
+  ];
+  return { calls, amount: input.amount, fee: input.fee, mintRecipientBytes32 };
+}
+var HEX_PREFIX_REGEX = /^0x[0-9a-fA-F]+$/;
+var NON_EVM_BUILDERS = {
+  solana: "buildSolanaReceiveIntent",
+  stellar: "buildStellarMintIntent",
+  starknet: "buildStarknetReceiveIntent"
+};
+function buildMintIntent(input) {
+  if (input.destination.ecosystem !== "evm") {
+    throw new UnsupportedError(
+      "unsupported_ecosystem",
+      `buildMintIntent builds EVM mints. Use ${NON_EVM_BUILDERS[input.destination.ecosystem]} for "${input.destination.id}".`
+    );
+  }
+  if (!HEX_PREFIX_REGEX.test(input.message)) {
+    throw new InvalidInputError(
+      "invalid_input",
+      "message must be a 0x-prefixed hex string"
+    );
+  }
+  if (!HEX_PREFIX_REGEX.test(input.attestation)) {
+    throw new InvalidInputError(
+      "invalid_input",
+      "attestation must be a 0x-prefixed hex string"
+    );
+  }
+  const data = viem.encodeFunctionData({
+    abi: messageTransmitterV2Abi,
+    functionName: "receiveMessage",
+    args: [input.message, input.attestation]
+  });
+  return {
+    destination: input.destination,
+    call: {
+      to: input.destination.messageTransmitter,
+      data,
+      value: 0n
+    }
+  };
+}
+
+// src/starknet/address.ts
+var STARKNET_FELT_RE = /^0x[a-fA-F0-9]{1,64}$/;
+function isValidStarknetFelt(s2) {
+  return STARKNET_FELT_RE.test(s2);
+}
+function assertStarknetFelt(s2) {
+  if (!isValidStarknetFelt(s2)) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `Not a valid Starknet felt: ${s2}`
+    );
+  }
+  return s2;
+}
+function feltToBytes32Hex(felt) {
+  if (!isValidStarknetFelt(felt)) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `Not a valid Starknet felt: ${felt}`
+    );
+  }
+  const stripped = felt.slice(2);
+  if (stripped.length > 64) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `Starknet felt exceeds 32 bytes: ${felt}`
+    );
+  }
+  return `0x${stripped.padStart(64, "0")}`;
+}
+function bytes32HexToFelt(hex) {
+  const stripped = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (stripped.length > 64) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `bytes32 input exceeds 32 bytes (${stripped.length / 2})`
+    );
+  }
+  const stripped64 = stripped.padStart(64, "0").replace(/^0+/, "");
+  const canonical = stripped64.length === 0 ? "0" : stripped64;
+  return `0x${canonical}`;
+}
+function feltToBigInt(felt) {
+  if (!isValidStarknetFelt(felt)) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `Not a valid Starknet felt: ${felt}`
+    );
+  }
+  return BigInt(felt);
+}
+function u256ToFelts(value) {
+  if (value < 0n) {
+    throw new RangeError(
+      `u256ToFelts: value must be non-negative, got ${value}`
+    );
+  }
+  const u = starknet.cairo.uint256(value);
+  return [u.low.toString(), u.high.toString()];
+}
+function feltToString(value) {
+  return starknet.num.toBigInt(value).toString();
+}
+function bytesToByteArrayFelts(bytes) {
+  const CHUNK = 31;
+  const dataFelts = [];
+  let i = 0;
+  while (i + CHUNK <= bytes.length) {
+    dataFelts.push(bytesToBigIntBE(bytes.subarray(i, i + CHUNK)).toString());
+    i += CHUNK;
+  }
+  const rest = bytes.subarray(i);
+  const pendingWord = bytesToBigIntBE(rest).toString();
+  const pendingWordLen = rest.length.toString();
+  return [
+    dataFelts.length.toString(),
+    ...dataFelts,
+    pendingWord,
+    pendingWordLen
+  ];
+}
+function bytesToBigIntBE(bytes) {
+  let n = 0n;
+  for (const b of bytes) n = n << 8n | BigInt(b);
+  return n;
+}
+function hexToByteArrayFelts(hex) {
+  const stripped = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(stripped.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(stripped.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytesToByteArrayFelts(bytes);
+}
+
+// src/starknet/burn.ts
+function buildStarknetBurnIntent(input) {
+  if (input.source.ecosystem !== "starknet") {
+    throw new InvalidInputError(
+      "invalid_chain",
+      `source must be Starknet, got ${input.source.ecosystem}`
+    );
+  }
+  if (input.amount <= 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `amount must be positive, got ${input.amount}`
+    );
+  }
+  if (input.maxFee < 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `maxFee must be non-negative, got ${input.maxFee}`
+    );
+  }
+  if (input.mintRecipient < 0n) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `mintRecipient must be non-negative, got ${input.mintRecipient}`
+    );
+  }
+  const withHook = !!input.hookData && input.hookData.length > 0;
+  const entrypoint = withHook ? "deposit_for_burn_with_hook" : "deposit_for_burn";
+  const [amountLo, amountHi] = u256ToFelts(input.amount);
+  const [recipLo, recipHi] = u256ToFelts(input.mintRecipient);
+  const [callerLo, callerHi] = u256ToFelts(input.destinationCaller);
+  const [maxFeeLo, maxFeeHi] = u256ToFelts(input.maxFee);
+  const calldata = [
+    amountLo,
+    amountHi,
+    feltToString(input.destinationDomain),
+    recipLo,
+    recipHi,
+    assertStarknetFelt(input.source.usdc),
+    callerLo,
+    callerHi,
+    maxFeeLo,
+    maxFeeHi,
+    feltToString(input.minFinalityThreshold)
+  ];
+  if (withHook) {
+    calldata.push(...bytesToByteArrayFelts(input.hookData));
+  }
+  return {
+    source: input.source,
+    destinationDomain: input.destinationDomain,
+    amount: input.amount,
+    maxFee: input.maxFee,
+    call: {
+      contractAddress: input.source.tokenMessengerMinter,
+      entrypoint,
+      calldata
+    },
+    withHook
+  };
+}
+function buildStarknetApproveCall(args) {
+  if (args.source.ecosystem !== "starknet") {
+    throw new InvalidInputError(
+      "invalid_chain",
+      `source must be Starknet, got ${args.source.ecosystem}`
+    );
+  }
+  if (args.amount <= 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `amount must be positive, got ${args.amount}`
+    );
+  }
+  const [lo, hi] = u256ToFelts(args.amount);
+  return {
+    contractAddress: args.source.usdc,
+    entrypoint: "approve",
+    calldata: [assertStarknetFelt(args.spender), lo, hi]
+  };
+}
+
+// src/starknet/receive.ts
+function buildStarknetReceiveIntent(input) {
+  if (input.destination.ecosystem !== "starknet") {
+    throw new InvalidInputError(
+      "invalid_chain",
+      `destination must be Starknet, got ${input.destination.ecosystem}`
+    );
+  }
+  if (!input.message.startsWith("0x") || input.message.length < 90) {
+    throw new InvalidInputError(
+      "invalid_input",
+      "message must be a 0x-prefixed hex blob of at least 44 bytes"
+    );
+  }
+  if (!input.attestation.startsWith("0x") || input.attestation.length < 4) {
+    throw new InvalidInputError(
+      "invalid_input",
+      "attestation must be a 0x-prefixed hex blob"
+    );
+  }
+  const calldata = [
+    ...hexToByteArrayFelts(input.message),
+    ...hexToByteArrayFelts(input.attestation)
+  ];
+  return {
+    destination: input.destination,
+    call: {
+      contractAddress: input.destination.messageTransmitter,
+      entrypoint: "receive_message",
+      calldata
+    }
+  };
+}
+function isValidStellarStrkey(s2) {
+  return stellarSdk.StrKey.isValidEd25519PublicKey(s2) || stellarSdk.StrKey.isValidMed25519PublicKey(s2) || stellarSdk.StrKey.isValidContract(s2);
+}
+function strkeyType(s2) {
+  if (stellarSdk.StrKey.isValidEd25519PublicKey(s2)) return "G";
+  if (stellarSdk.StrKey.isValidMed25519PublicKey(s2)) return "M";
+  if (stellarSdk.StrKey.isValidContract(s2)) return "C";
+  throw new InvalidInputError(
+    "invalid_address",
+    `Invalid Stellar strkey: ${s2}`
+  );
+}
+function decodeStrkeyToBytes32(s2) {
+  if (stellarSdk.StrKey.isValidEd25519PublicKey(s2))
+    return stellarSdk.StrKey.decodeEd25519PublicKey(s2);
+  if (stellarSdk.StrKey.isValidContract(s2)) return stellarSdk.StrKey.decodeContract(s2);
+  if (stellarSdk.StrKey.isValidMed25519PublicKey(s2)) {
+    return stellarSdk.StrKey.decodeMed25519PublicKey(s2).slice(0, 32);
+  }
+  throw new InvalidInputError(
+    "invalid_address",
+    `Invalid Stellar strkey: ${s2}`
+  );
+}
+function encodeContractStrkey(bytes) {
+  if (bytes.length !== 32) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `encodeContractStrkey: bytes must be 32, got ${bytes.length}`
+    );
+  }
+  return stellarSdk.StrKey.encodeContract(Buffer.from(bytes));
+}
+function contractStrkeyToBytes32Hex(s2) {
+  if (!stellarSdk.StrKey.isValidContract(s2)) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `Not a Stellar contract strkey (C\u2026): ${s2}`
+    );
+  }
+  const bytes = stellarSdk.StrKey.decodeContract(s2);
+  let hex = "0x";
+  for (const b of bytes) hex += b.toString(16).padStart(2, "0");
+  return hex;
+}
+
+// src/stellar/precision.ts
+var DECIMAL_FACTOR = 10n ** BigInt(STELLAR_USDC_DECIMALS - CCTP_USDC_DECIMALS);
+function stellarSubunitsToCanonical(stellarSubunits) {
+  if (stellarSubunits < 0n) {
+    throw new RangeError(
+      `stellarSubunitsToCanonical: amount must be non-negative, got ${stellarSubunits}`
+    );
+  }
+  return stellarSubunits / DECIMAL_FACTOR;
+}
+function canonicalToStellarSubunits(canonicalSubunits) {
+  if (canonicalSubunits < 0n) {
+    throw new RangeError(
+      `canonicalToStellarSubunits: amount must be non-negative, got ${canonicalSubunits}`
+    );
+  }
+  return canonicalSubunits * DECIMAL_FACTOR;
+}
+function stellarBurnDust(stellarSubunits) {
+  return stellarSubunits % DECIMAL_FACTOR;
+}
+var VERSION_OFFSET = 24;
+var LENGTH_OFFSET = 28;
+var PAYLOAD_OFFSET = 32;
+var HOOK_DATA_VERSION = 0;
+function buildStellarForwarderHookData(forwardRecipientStrkey, integratorPayload) {
+  if (!isValidStellarStrkey(forwardRecipientStrkey)) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `Stellar forwardRecipient must be a G/M/C strkey, got: ${forwardRecipientStrkey}`
+    );
+  }
+  const recipientBytes = new TextEncoder().encode(forwardRecipientStrkey);
+  const payloadLength = integratorPayload?.length ?? 0;
+  const total = PAYLOAD_OFFSET + recipientBytes.length + payloadLength;
+  const buf = new Uint8Array(total);
+  writeU32BE(buf, VERSION_OFFSET, HOOK_DATA_VERSION);
+  writeU32BE(buf, LENGTH_OFFSET, recipientBytes.length);
+  buf.set(recipientBytes, PAYLOAD_OFFSET);
+  if (integratorPayload && integratorPayload.length > 0) {
+    buf.set(integratorPayload, PAYLOAD_OFFSET + recipientBytes.length);
+  }
+  let hex = "0x";
+  for (const b of buf) hex += b.toString(16).padStart(2, "0");
+  return hex;
+}
+function writeU32BE(buf, offset, value) {
+  buf[offset] = value >>> 24 & 255;
+  buf[offset + 1] = value >>> 16 & 255;
+  buf[offset + 2] = value >>> 8 & 255;
+  buf[offset + 3] = value & 255;
+}
+function buildStellarApproveInvocation(input) {
+  if (input.source.ecosystem !== "stellar") {
+    throw new InvalidInputError(
+      "invalid_chain",
+      `source must be Stellar, got ${input.source.ecosystem}`
+    );
+  }
+  if (input.amount <= 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `amount must be positive, got ${input.amount}`
+    );
+  }
+  if (input.expirationLedger < 0) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `expirationLedger must be \u2265 0, got ${input.expirationLedger}`
+    );
+  }
+  const args = [
+    new stellarSdk.Address(input.owner).toScVal(),
+    new stellarSdk.Address(input.spender).toScVal(),
+    stellarSdk.nativeToScVal(input.amount, { type: "i128" }),
+    stellarSdk.nativeToScVal(input.expirationLedger, { type: "u32" })
+  ];
+  const operation = new stellarSdk.Contract(input.source.usdc).call("approve", ...args);
+  return {
+    ecosystem: "stellar",
+    contractId: input.source.usdc,
+    functionName: "approve",
+    args,
+    operation
+  };
+}
+function buildStellarBurnIntent(input) {
+  if (input.source.ecosystem !== "stellar") {
+    throw new InvalidInputError(
+      "invalid_chain",
+      `source must be a Stellar chain, got ${input.source.ecosystem}`
+    );
+  }
+  if (!isValidStellarStrkey(input.caller)) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `caller is not a valid Stellar strkey: ${input.caller}`
+    );
+  }
+  if (input.mintRecipientBytes32.length !== 32) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `mintRecipientBytes32 must be 32 bytes, got ${input.mintRecipientBytes32.length}`
+    );
+  }
+  if (input.destinationCallerBytes32.length !== 32) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `destinationCallerBytes32 must be 32 bytes, got ${input.destinationCallerBytes32.length}`
+    );
+  }
+  if (input.amount <= 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `amount must be positive, got ${input.amount}`
+    );
+  }
+  if (input.maxFee < 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `maxFee must be non-negative, got ${input.maxFee}`
+    );
+  }
+  const withHook = !!input.hookData && input.hookData.length > 0;
+  const fn = withHook ? "deposit_for_burn_with_hook" : "deposit_for_burn";
+  const tmm = input.source.tokenMessengerMinter;
+  const usdcSac = input.source.usdc;
+  const args = [
+    new stellarSdk.Address(input.caller).toScVal(),
+    stellarSdk.nativeToScVal(input.amount, { type: "i128" }),
+    stellarSdk.nativeToScVal(input.destinationDomain, { type: "u32" }),
+    stellarSdk.nativeToScVal(Buffer.from(input.mintRecipientBytes32), {
+      type: "bytes"
+    }),
+    new stellarSdk.Address(usdcSac).toScVal(),
+    stellarSdk.nativeToScVal(Buffer.from(input.destinationCallerBytes32), {
+      type: "bytes"
+    }),
+    stellarSdk.nativeToScVal(input.maxFee, { type: "i128" }),
+    stellarSdk.nativeToScVal(input.minFinalityThreshold, { type: "u32" })
+  ];
+  if (withHook) {
+    args.push(stellarSdk.nativeToScVal(Buffer.from(input.hookData), { type: "bytes" }));
+  }
+  const operation = new stellarSdk.Contract(tmm).call(fn, ...args);
+  return {
+    source: input.source,
+    destinationDomain: input.destinationDomain,
+    amount: input.amount,
+    maxFee: input.maxFee,
+    invocation: {
+      ecosystem: "stellar",
+      contractId: tmm,
+      functionName: fn,
+      args,
+      operation
+    },
+    withHook
+  };
+}
+function strkeyTo32Bytes(strkey) {
+  return decodeStrkeyToBytes32(strkey);
+}
+function buildStellarMintIntent(input) {
+  if (input.destination.ecosystem !== "stellar") {
+    throw new InvalidInputError(
+      "invalid_chain",
+      `destination must be a Stellar chain, got ${input.destination.ecosystem}`
+    );
+  }
+  if (input.message.length < 44) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `message must be at least 44 bytes, got ${input.message.length}`
+    );
+  }
+  if (input.attestation.length === 0) {
+    throw new InvalidInputError(
+      "invalid_input",
+      "attestation must not be empty"
+    );
+  }
+  const args = [
+    stellarSdk.nativeToScVal(Buffer.from(input.message), { type: "bytes" }),
+    stellarSdk.nativeToScVal(Buffer.from(input.attestation), { type: "bytes" })
+  ];
+  const operation = new stellarSdk.Contract(input.destination.cctpForwarder).call(
+    "mint_and_forward",
+    ...args
+  );
+  return {
+    destination: input.destination,
+    invocation: {
+      ecosystem: "stellar",
+      contractId: input.destination.cctpForwarder,
+      functionName: "mint_and_forward",
+      args,
+      operation
+    }
+  };
+}
+var enc = new TextEncoder();
+var SEEDS = {
+  tokenMessenger: enc.encode("token_messenger"),
+  tokenMinter: enc.encode("token_minter"),
+  senderAuthority: enc.encode("sender_authority"),
+  remoteTokenMessenger: enc.encode("remote_token_messenger"),
+  localToken: enc.encode("local_token"),
+  tokenPair: enc.encode("token_pair"),
+  custody: enc.encode("custody"),
+  denylistAccount: enc.encode("denylist_account"),
+  messageTransmitter: enc.encode("message_transmitter"),
+  messageTransmitterAuthority: enc.encode("message_transmitter_authority"),
+  usedNonce: enc.encode("used_nonce"),
+  eventAuthority: enc.encode("__event_authority")
+};
+function deriveTokenMessenger(tokenMessengerMinterProgram) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.tokenMessenger],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveTokenMinter(tokenMessengerMinterProgram) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.tokenMinter],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveSenderAuthority(tokenMessengerMinterProgram) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.senderAuthority],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveRemoteTokenMessenger(tokenMessengerMinterProgram, domain) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.remoteTokenMessenger, enc.encode(domain.toString())],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveLocalToken(tokenMessengerMinterProgram, mint) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.localToken, mint.toBytes()],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveTokenPair(tokenMessengerMinterProgram, sourceDomain, sourceTokenBytes32) {
+  if (sourceTokenBytes32.length !== 32) {
+    throw new Error(
+      `deriveTokenPair: sourceTokenBytes32 must be 32 bytes, got ${sourceTokenBytes32.length}`
+    );
+  }
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.tokenPair, enc.encode(sourceDomain.toString()), sourceTokenBytes32],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveCustodyTokenAccount(tokenMessengerMinterProgram, mint) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.custody, mint.toBytes()],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveDenylistAccount(tokenMessengerMinterProgram, owner) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.denylistAccount, owner.toBytes()],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveMessageTransmitter(messageTransmitterProgram) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.messageTransmitter],
+    messageTransmitterProgram
+  )[0];
+}
+function deriveMessageTransmitterAuthority(messageTransmitterProgram, receiverProgram) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.messageTransmitterAuthority, receiverProgram.toBytes()],
+    messageTransmitterProgram
+  )[0];
+}
+function deriveUsedNonce(messageTransmitterProgram, messageBytes) {
+  if (messageBytes.length < 44) {
+    throw new Error(
+      `deriveUsedNonce: message must be at least 44 bytes, got ${messageBytes.length}`
+    );
+  }
+  const nonce = messageBytes.slice(12, 44);
+  return web3_js.PublicKey.findProgramAddressSync(
+    [SEEDS.usedNonce, nonce],
+    messageTransmitterProgram
+  )[0];
+}
+function deriveEventAuthority(programId) {
+  return web3_js.PublicKey.findProgramAddressSync([SEEDS.eventAuthority], programId)[0];
+}
+function anchorDiscriminator(snakeCaseName) {
+  const bytes = new TextEncoder().encode(`global:${snakeCaseName}`);
+  return sha256.sha256(bytes).slice(0, 8);
+}
+var DISCRIMINATOR_DEPOSIT_FOR_BURN = anchorDiscriminator("deposit_for_burn");
+var DISCRIMINATOR_DEPOSIT_FOR_BURN_WITH_HOOK = anchorDiscriminator("deposit_for_burn_with_hook");
+var DISCRIMINATOR_RECEIVE_MESSAGE = anchorDiscriminator("receive_message");
+function createWriter(initialSize = 64) {
+  return { buf: buffer.Buffer.alloc(initialSize), offset: 0 };
+}
+function ensure(w, extra) {
+  if (w.offset + extra <= w.buf.length) return;
+  const next = buffer.Buffer.alloc(Math.max(w.buf.length * 2, w.offset + extra));
+  w.buf.copy(next, 0, 0, w.offset);
+  w.buf = next;
+}
+function writeU32LE(w, value) {
+  ensure(w, 4);
+  w.buf.writeUInt32LE(value >>> 0, w.offset);
+  w.offset += 4;
+}
+function writeU64LE(w, value) {
+  if (value < 0n) {
+    throw new RangeError(
+      `writeU64LE: value must be non-negative, got ${value}`
+    );
+  }
+  ensure(w, 8);
+  w.buf.writeBigUInt64LE(value, w.offset);
+  w.offset += 8;
+}
+function writePubkey(w, bytes) {
+  if (bytes.length !== 32) {
+    throw new RangeError(`writePubkey: expected 32 bytes, got ${bytes.length}`);
+  }
+  ensure(w, 32);
+  w.buf.set(bytes, w.offset);
+  w.offset += 32;
+}
+function writeBytes(w, bytes) {
+  writeU32LE(w, bytes.length);
+  ensure(w, bytes.length);
+  w.buf.set(bytes, w.offset);
+  w.offset += bytes.length;
+}
+function withDiscriminator(discriminator, w) {
+  const out = buffer.Buffer.alloc(discriminator.length + w.offset);
+  out.set(discriminator, 0);
+  w.buf.copy(out, discriminator.length, 0, w.offset);
+  return out;
+}
+
+// src/solana/burn.ts
+var ANY_DESTINATION_CALLER2 = new web3_js.PublicKey(new Uint8Array(32));
+var MAX_USDC_AMOUNT2 = 10000000n * 1000000n;
+function buildSolanaBurnIntent(input) {
+  if (input.source.ecosystem !== "solana") {
+    throw new InvalidInputError(
+      "invalid_chain",
+      `source must be a Solana chain, got ${input.source.ecosystem}`
+    );
+  }
+  if (input.amount <= 0n) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      `amount must be positive, got ${input.amount}`
+    );
+  }
+  if (input.amount > MAX_USDC_AMOUNT2) {
+    throw new InvalidInputError(
+      "amount_too_large",
+      `amount exceeds CCTP per-burn cap of 10M USDC`
+    );
+  }
+  if (input.amount <= input.maxFee) {
+    throw new InvalidInputError(
+      "invalid_amount",
+      "amount must exceed maxFee (program would revert MaxFeeMustBeLessThanAmount)"
+    );
+  }
+  if (input.mintRecipientBytes32.length !== 32) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `mintRecipientBytes32 must be 32 bytes, got ${input.mintRecipientBytes32.length}`
+    );
+  }
+  const destCaller = input.destinationCallerBytes32 ?? new Uint8Array(32);
+  if (destCaller.length !== 32) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `destinationCallerBytes32 must be 32 bytes, got ${destCaller.length}`
+    );
+  }
+  if (input.hookData !== void 0 && input.hookData.length === 0) {
+    throw new InvalidInputError(
+      "invalid_input",
+      "hookData must be non-empty (use the no-hook builder for plain burns)"
+    );
+  }
+  const tmmProgram = new web3_js.PublicKey(input.source.tokenMessengerMinter);
+  const mtProgram = new web3_js.PublicKey(input.source.messageTransmitter);
+  const burnTokenMint = new web3_js.PublicKey(input.source.usdc);
+  const senderAuthorityPda = deriveSenderAuthority(tmmProgram);
+  const denylistAccount = deriveDenylistAccount(tmmProgram, input.owner);
+  const messageTransmitter = deriveMessageTransmitter(mtProgram);
+  const tokenMessenger = deriveTokenMessenger(tmmProgram);
+  const remoteTokenMessenger = deriveRemoteTokenMessenger(
+    tmmProgram,
+    input.destinationDomain
+  );
+  const tokenMinter = deriveTokenMinter(tmmProgram);
+  const localToken = deriveLocalToken(tmmProgram, burnTokenMint);
+  const eventAuthority = deriveEventAuthority(tmmProgram);
+  const keys = [
+    { pubkey: input.owner, isSigner: true, isWritable: false },
+    { pubkey: input.owner, isSigner: true, isWritable: true },
+    // event_rent_payer = owner
+    { pubkey: senderAuthorityPda, isSigner: false, isWritable: false },
+    { pubkey: input.ownerUsdcAta, isSigner: false, isWritable: true },
+    { pubkey: denylistAccount, isSigner: false, isWritable: false },
+    { pubkey: messageTransmitter, isSigner: false, isWritable: true },
+    { pubkey: tokenMessenger, isSigner: false, isWritable: false },
+    { pubkey: remoteTokenMessenger, isSigner: false, isWritable: false },
+    { pubkey: tokenMinter, isSigner: false, isWritable: false },
+    { pubkey: localToken, isSigner: false, isWritable: true },
+    { pubkey: burnTokenMint, isSigner: false, isWritable: true },
+    {
+      pubkey: input.messageSentEventDataKey,
+      isSigner: true,
+      isWritable: true
+    },
+    { pubkey: mtProgram, isSigner: false, isWritable: false },
+    { pubkey: tmmProgram, isSigner: false, isWritable: false },
+    { pubkey: splToken.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: web3_js.SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: eventAuthority, isSigner: false, isWritable: false },
+    { pubkey: tmmProgram, isSigner: false, isWritable: false }
+  ];
+  const writer = createWriter(96);
+  writeU64LE(writer, input.amount);
+  writeU32LE(writer, input.destinationDomain);
+  writePubkey(writer, input.mintRecipientBytes32);
+  writePubkey(writer, destCaller);
+  writeU64LE(writer, input.maxFee);
+  writeU32LE(writer, input.minFinalityThreshold);
+  if (input.hookData !== void 0) {
+    writeBytes(writer, input.hookData);
+  }
+  const discriminator = input.hookData !== void 0 ? DISCRIMINATOR_DEPOSIT_FOR_BURN_WITH_HOOK : DISCRIMINATOR_DEPOSIT_FOR_BURN;
+  const data = withDiscriminator(discriminator, writer);
+  return {
+    source: input.source,
+    destinationDomain: input.destinationDomain,
+    amount: input.amount,
+    maxFee: input.maxFee,
+    messageSentEventDataKey: input.messageSentEventDataKey,
+    withHook: input.hookData !== void 0,
+    instruction: {
+      programId: tmmProgram,
+      keys,
+      data,
+      ecosystem: "solana"
+    }
+  };
+}
+function burnIntentToTransactionInstruction(intent) {
+  return new web3_js.TransactionInstruction({
+    programId: intent.instruction.programId,
+    keys: intent.instruction.keys,
+    data: intent.instruction.data
+  });
+}
+function buildSolanaReceiveIntent(input) {
+  if (input.destination.ecosystem !== "solana") {
+    throw new InvalidInputError(
+      "invalid_chain",
+      `destination must be a Solana chain, got ${input.destination.ecosystem}`
+    );
+  }
+  if (input.message.length < 44) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `message must be at least 44 bytes (Iris messages are much larger), got ${input.message.length}`
+    );
+  }
+  if (input.attestation.length === 0) {
+    throw new InvalidInputError(
+      "invalid_input",
+      "attestation must not be empty"
+    );
+  }
+  if (input.sourceTokenBytes32.length !== 32) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `sourceTokenBytes32 must be 32 bytes, got ${input.sourceTokenBytes32.length}`
+    );
+  }
+  const tmmProgram = new web3_js.PublicKey(input.destination.tokenMessengerMinter);
+  const mtProgram = new web3_js.PublicKey(input.destination.messageTransmitter);
+  const localMint = new web3_js.PublicKey(input.destination.usdc);
+  const authorityPda = deriveMessageTransmitterAuthority(mtProgram, tmmProgram);
+  const messageTransmitter = deriveMessageTransmitter(mtProgram);
+  const usedNonce = deriveUsedNonce(mtProgram, input.message);
+  const mtEventAuthority = deriveEventAuthority(mtProgram);
+  const tokenMessenger = deriveTokenMessenger(tmmProgram);
+  const remoteTokenMessenger = deriveRemoteTokenMessenger(
+    tmmProgram,
+    input.sourceDomain
+  );
+  const tokenMinter = deriveTokenMinter(tmmProgram);
+  const localToken = deriveLocalToken(tmmProgram, localMint);
+  const tokenPair = deriveTokenPair(
+    tmmProgram,
+    input.sourceDomain,
+    input.sourceTokenBytes32
+  );
+  const custodyTokenAccount = deriveCustodyTokenAccount(tmmProgram, localMint);
+  const tmmEventAuthority = deriveEventAuthority(tmmProgram);
+  const keys = [
+    { pubkey: input.payer, isSigner: true, isWritable: true },
+    { pubkey: input.payer, isSigner: true, isWritable: false },
+    // caller = payer
+    { pubkey: authorityPda, isSigner: false, isWritable: false },
+    { pubkey: messageTransmitter, isSigner: false, isWritable: false },
+    { pubkey: usedNonce, isSigner: false, isWritable: true },
+    { pubkey: tmmProgram, isSigner: false, isWritable: false },
+    // receiver
+    { pubkey: web3_js.SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: mtEventAuthority, isSigner: false, isWritable: false },
+    { pubkey: mtProgram, isSigner: false, isWritable: false },
+    // Remaining accounts for TMM handle_receive
+    { pubkey: tokenMessenger, isSigner: false, isWritable: false },
+    { pubkey: remoteTokenMessenger, isSigner: false, isWritable: false },
+    { pubkey: tokenMinter, isSigner: false, isWritable: true },
+    { pubkey: localToken, isSigner: false, isWritable: true },
+    { pubkey: tokenPair, isSigner: false, isWritable: false },
+    { pubkey: input.feeRecipientUsdcAta, isSigner: false, isWritable: true },
+    { pubkey: input.recipientUsdcAta, isSigner: false, isWritable: true },
+    { pubkey: custodyTokenAccount, isSigner: false, isWritable: true },
+    { pubkey: splToken.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: tmmEventAuthority, isSigner: false, isWritable: false },
+    { pubkey: tmmProgram, isSigner: false, isWritable: false }
+  ];
+  const writer = createWriter(
+    input.message.length + input.attestation.length + 16
+  );
+  writeBytes(writer, input.message);
+  writeBytes(writer, input.attestation);
+  const data = withDiscriminator(DISCRIMINATOR_RECEIVE_MESSAGE, writer);
+  return {
+    destination: input.destination,
+    instruction: {
+      programId: mtProgram,
+      keys,
+      data,
+      ecosystem: "solana"
+    }
+  };
+}
+function receiveIntentToTransactionInstruction(intent) {
+  return new web3_js.TransactionInstruction({
+    programId: intent.instruction.programId,
+    keys: intent.instruction.keys,
+    data: intent.instruction.data
+  });
+}
+var FEE_RECIPIENT_OFFSET = 109;
+var FEE_RECIPIENT_END = 141;
+function parseTokenMessengerFeeRecipient(accountData) {
+  if (accountData.length < FEE_RECIPIENT_END) {
+    throw new InvalidInputError(
+      "invalid_input",
+      `TokenMessenger account too small (${accountData.length} bytes) \u2014 cannot read fee_recipient.`
+    );
+  }
+  return new web3_js.PublicKey(
+    accountData.slice(FEE_RECIPIENT_OFFSET, FEE_RECIPIENT_END)
+  );
+}
+
+// src/index.ts
+var VERSION2 = "0.1.0";
+
+exports.ANY_DESTINATION_CALLER = ANY_DESTINATION_CALLER;
+exports.Arbitrum = Arbitrum;
+exports.ArbitrumSepolia = ArbitrumSepolia;
+exports.Arc = Arc;
+exports.ArcTestnet = ArcTestnet;
+exports.Avalanche = Avalanche;
+exports.AvalancheFuji = AvalancheFuji;
+exports.Base = Base;
+exports.BaseSepolia = BaseSepolia;
+exports.CCTP_FORWARDER_STELLAR_MAINNET = CCTP_FORWARDER_STELLAR_MAINNET;
+exports.CCTP_FORWARDER_STELLAR_TESTNET = CCTP_FORWARDER_STELLAR_TESTNET;
+exports.CCTP_FORWARD_HOOK_DATA = CCTP_FORWARD_HOOK_DATA;
+exports.CCTP_FORWARD_HOOK_DATA_LENGTH = CCTP_FORWARD_HOOK_DATA_LENGTH;
+exports.CCTP_USDC_DECIMALS = CCTP_USDC_DECIMALS;
+exports.CHAINS = CHAINS;
+exports.CctpError = CctpError;
+exports.Codex = Codex;
+exports.CodexTestnet = CodexTestnet;
+exports.Cronos = Cronos;
+exports.CronosTestnet = CronosTestnet;
+exports.DISCRIMINATOR_DEPOSIT_FOR_BURN = DISCRIMINATOR_DEPOSIT_FOR_BURN;
+exports.DISCRIMINATOR_DEPOSIT_FOR_BURN_WITH_HOOK = DISCRIMINATOR_DEPOSIT_FOR_BURN_WITH_HOOK;
+exports.DISCRIMINATOR_RECEIVE_MESSAGE = DISCRIMINATOR_RECEIVE_MESSAGE;
+exports.EVM_MAINNET_CHAINS = EVM_MAINNET_CHAINS;
+exports.EVM_TESTNET_CHAINS = EVM_TESTNET_CHAINS;
+exports.Edge = Edge;
+exports.EdgeTestnet = EdgeTestnet;
+exports.Ethereum = Ethereum;
+exports.EthereumSepolia = EthereumSepolia;
+exports.FINALITY_FAST = FINALITY_FAST;
+exports.FINALITY_STANDARD = FINALITY_STANDARD;
+exports.HyperEVM = HyperEVM;
+exports.HyperEVMTestnet = HyperEVMTestnet;
+exports.IRIS_MAINNET_URL = IRIS_MAINNET_URL;
+exports.IRIS_SANDBOX_URL = IRIS_SANDBOX_URL;
+exports.Injective = Injective;
+exports.InjectiveTestnet = InjectiveTestnet;
+exports.Ink = Ink;
+exports.InkTestnet = InkTestnet;
+exports.InvalidAddressError = InvalidAddressError;
+exports.InvalidBytes32Error = InvalidBytes32Error;
+exports.InvalidInputError = InvalidInputError;
+exports.IrisAbortedError = IrisAbortedError;
+exports.IrisError = IrisError;
+exports.IrisHttpError = IrisHttpError;
+exports.IrisNetworkError = IrisNetworkError;
+exports.IrisParseError = IrisParseError;
+exports.IrisRateLimitedError = IrisRateLimitedError;
+exports.Linea = Linea;
+exports.LineaSepolia = LineaSepolia;
+exports.MESSAGE_TRANSMITTER_STELLAR_MAINNET = MESSAGE_TRANSMITTER_STELLAR_MAINNET;
+exports.MESSAGE_TRANSMITTER_STELLAR_TESTNET = MESSAGE_TRANSMITTER_STELLAR_TESTNET;
+exports.MESSAGE_TRANSMITTER_V2_EVM_MAINNET = MESSAGE_TRANSMITTER_V2_EVM_MAINNET;
+exports.MESSAGE_TRANSMITTER_V2_EVM_TESTNET = MESSAGE_TRANSMITTER_V2_EVM_TESTNET;
+exports.MESSAGE_TRANSMITTER_V2_SOLANA = MESSAGE_TRANSMITTER_V2_SOLANA;
+exports.MESSAGE_TRANSMITTER_V2_STARKNET_MAINNET = MESSAGE_TRANSMITTER_V2_STARKNET_MAINNET;
+exports.MESSAGE_TRANSMITTER_V2_STARKNET_SEPOLIA = MESSAGE_TRANSMITTER_V2_STARKNET_SEPOLIA;
+exports.Monad = Monad;
+exports.MonadTestnet = MonadTestnet;
+exports.Morph = Morph;
+exports.MorphTestnet = MorphTestnet;
+exports.Optimism = Optimism;
+exports.OptimismSepolia = OptimismSepolia;
+exports.Pharos = Pharos;
+exports.PharosTestnet = PharosTestnet;
+exports.Plasma = Plasma;
+exports.PlasmaTestnet = PlasmaTestnet;
+exports.Plume = Plume;
+exports.PlumeTestnet = PlumeTestnet;
+exports.Polygon = Polygon;
+exports.PolygonAmoyTestnet = PolygonAmoyTestnet;
+exports.ProtocolError = ProtocolError;
+exports.SOLANA_ANY_DESTINATION_CALLER = ANY_DESTINATION_CALLER2;
+exports.SOLANA_CCTP_DOMAIN = SOLANA_CCTP_DOMAIN;
+exports.SOLANA_CCTP_PDA_SEEDS = SEEDS;
+exports.STARKNET_CCTP_DOMAIN = STARKNET_CCTP_DOMAIN;
+exports.STARKNET_CHAIN_ID_MAINNET = STARKNET_CHAIN_ID_MAINNET;
+exports.STARKNET_CHAIN_ID_SEPOLIA = STARKNET_CHAIN_ID_SEPOLIA;
+exports.STELLAR_CCTP_DOMAIN = STELLAR_CCTP_DOMAIN;
+exports.STELLAR_NETWORK_PASSPHRASE_MAINNET = STELLAR_NETWORK_PASSPHRASE_MAINNET;
+exports.STELLAR_NETWORK_PASSPHRASE_TESTNET = STELLAR_NETWORK_PASSPHRASE_TESTNET;
+exports.STELLAR_USDC_DECIMALS = STELLAR_USDC_DECIMALS;
+exports.Sei = Sei;
+exports.SeiTestnet = SeiTestnet;
+exports.Solana = Solana;
+exports.SolanaDevnet = SolanaDevnet;
+exports.Sonic = Sonic;
+exports.SonicTestnet = SonicTestnet;
+exports.Starknet = Starknet;
+exports.StarknetSepolia = StarknetSepolia;
+exports.Stellar = Stellar;
+exports.StellarTestnet = StellarTestnet;
+exports.TOKEN_MESSENGER_MINTER_STELLAR_MAINNET = TOKEN_MESSENGER_MINTER_STELLAR_MAINNET;
+exports.TOKEN_MESSENGER_MINTER_STELLAR_TESTNET = TOKEN_MESSENGER_MINTER_STELLAR_TESTNET;
+exports.TOKEN_MESSENGER_MINTER_V2_SOLANA = TOKEN_MESSENGER_MINTER_V2_SOLANA;
+exports.TOKEN_MESSENGER_MINTER_V2_STARKNET_MAINNET = TOKEN_MESSENGER_MINTER_V2_STARKNET_MAINNET;
+exports.TOKEN_MESSENGER_MINTER_V2_STARKNET_SEPOLIA = TOKEN_MESSENGER_MINTER_V2_STARKNET_SEPOLIA;
+exports.TOKEN_MESSENGER_V2_EVM_MAINNET = TOKEN_MESSENGER_V2_EVM_MAINNET;
+exports.TOKEN_MESSENGER_V2_EVM_TESTNET = TOKEN_MESSENGER_V2_EVM_TESTNET;
+exports.TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET = TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET;
+exports.TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET = TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET;
+exports.USDC_ISSUER_STELLAR_MAINNET = USDC_ISSUER_STELLAR_MAINNET;
+exports.USDC_ISSUER_STELLAR_TESTNET = USDC_ISSUER_STELLAR_TESTNET;
+exports.USDC_SPL_DEVNET = USDC_SPL_DEVNET;
+exports.USDC_SPL_MAINNET = USDC_SPL_MAINNET;
+exports.USDC_STARKNET_MAINNET = USDC_STARKNET_MAINNET;
+exports.USDC_STARKNET_SEPOLIA = USDC_STARKNET_SEPOLIA;
+exports.Unichain = Unichain;
+exports.UnichainSepolia = UnichainSepolia;
+exports.UnknownChainError = UnknownChainError;
+exports.UnsupportedError = UnsupportedError;
+exports.VERSION = VERSION2;
+exports.WorldChain = WorldChain;
+exports.WorldChainSepolia = WorldChainSepolia;
+exports.XDC = XDC;
+exports.XDCApothem = XDCApothem;
+exports.XLayer = XLayer;
+exports.XLayerTestnet = XLayerTestnet;
+exports.anchorDiscriminator = anchorDiscriminator;
+exports.assertStarknetFelt = assertStarknetFelt;
+exports.attestationSeconds = attestationSeconds;
+exports.buildBurnIntent = buildBurnIntent;
+exports.buildBurnWithFeesIntent = buildBurnWithFeesIntent;
+exports.buildForwarderHookData = buildForwarderHookData;
+exports.buildMintIntent = buildMintIntent;
+exports.buildSolanaBurnIntent = buildSolanaBurnIntent;
+exports.buildSolanaReceiveIntent = buildSolanaReceiveIntent;
+exports.buildStarknetApproveCall = buildStarknetApproveCall;
+exports.buildStarknetBurnIntent = buildStarknetBurnIntent;
+exports.buildStarknetReceiveIntent = buildStarknetReceiveIntent;
+exports.buildStellarApproveInvocation = buildStellarApproveInvocation;
+exports.buildStellarBurnIntent = buildStellarBurnIntent;
+exports.buildStellarForwarderHookData = buildStellarForwarderHookData;
+exports.buildStellarMintIntent = buildStellarMintIntent;
+exports.burnIntentToTransactionInstruction = burnIntentToTransactionInstruction;
+exports.bytes32HexToFelt = bytes32HexToFelt;
+exports.bytesToByteArrayFelts = bytesToByteArrayFelts;
+exports.canonicalToStellarSubunits = canonicalToStellarSubunits;
+exports.chainByDomain = chainByDomain;
+exports.chainByEvmChainId = chainByEvmChainId;
+exports.chainsByNetwork = chainsByNetwork;
+exports.computeBurnFee = computeBurnFee;
+exports.computeMaxFee = computeMaxFee;
+exports.contractStrkeyToBytes32Hex = contractStrkeyToBytes32Hex;
+exports.createIrisLimiter = createIrisLimiter;
+exports.decodeBurnMessage = decodeBurnMessage;
+exports.decodeStrkeyToBytes32 = decodeStrkeyToBytes32;
+exports.defaultIrisLimiter = defaultIrisLimiter;
+exports.deriveCustodyTokenAccount = deriveCustodyTokenAccount;
+exports.deriveDenylistAccount = deriveDenylistAccount;
+exports.deriveEventAuthority = deriveEventAuthority;
+exports.deriveLocalToken = deriveLocalToken;
+exports.deriveMessageTransmitter = deriveMessageTransmitter;
+exports.deriveMessageTransmitterAuthority = deriveMessageTransmitterAuthority;
+exports.deriveRemoteTokenMessenger = deriveRemoteTokenMessenger;
+exports.deriveSenderAuthority = deriveSenderAuthority;
+exports.deriveTokenMessenger = deriveTokenMessenger;
+exports.deriveTokenMinter = deriveTokenMinter;
+exports.deriveTokenPair = deriveTokenPair;
+exports.deriveUsedNonce = deriveUsedNonce;
+exports.encodeContractStrkey = encodeContractStrkey;
+exports.explorerAddressUrl = explorerAddressUrl;
+exports.explorerTxUrl = explorerTxUrl;
+exports.feltToBigInt = feltToBigInt;
+exports.feltToBytes32Hex = feltToBytes32Hex;
+exports.fetchIrisJson = fetchIrisJson;
+exports.fromBytes32 = fromBytes32;
+exports.getBlockNumber = getBlockNumber;
+exports.getBurnFees = getBurnFees;
+exports.getChain = getChain;
+exports.getFastBurnAllowance = getFastBurnAllowance;
+exports.getGasPrice = getGasPrice;
+exports.getMessages = getMessages;
+exports.getSignedBurnQuote = getSignedBurnQuote;
+exports.getStandardMinFee = getStandardMinFee;
+exports.getStarknetClassHashAt = getStarknetClassHashAt;
+exports.getStarknetTransactionStatus = getStarknetTransactionStatus;
+exports.getTransactionStatus = getTransactionStatus;
+exports.getUsdcBalance = getUsdcBalance;
+exports.hexToByteArrayFelts = hexToByteArrayFelts;
+exports.irisBaseUrl = irisBaseUrl;
+exports.isAddress = isAddress;
+exports.isCctpError = isCctpError;
+exports.isChainId = isChainId;
+exports.isEvmChain = isEvmChain;
+exports.isForwardDone = isForwardDone;
+exports.isForwarderHookData = isForwarderHookData;
+exports.isNonceUsed = isNonceUsed;
+exports.isSolanaChain = isSolanaChain;
+exports.isStarknetChain = isStarknetChain;
+exports.isStarknetNonceUsed = isStarknetNonceUsed;
+exports.isStellarChain = isStellarChain;
+exports.isStellarNonceUsed = isStellarNonceUsed;
+exports.isValidStarknetFelt = isValidStarknetFelt;
+exports.isValidStellarStrkey = isValidStellarStrkey;
+exports.messageTransmitterV2Abi = messageTransmitterV2Abi;
+exports.parseFeeBps = parseFeeBps;
+exports.parseForwarderFee = parseForwarderFee;
+exports.parseTokenMessengerFeeRecipient = parseTokenMessengerFeeRecipient;
+exports.pickFeeTier = pickFeeTier;
+exports.pickForwarderFee = pickForwarderFee;
+exports.pollBudget = pollBudget;
+exports.pollMessages = pollMessages;
+exports.reattest = reattest;
+exports.receiveIntentToTransactionInstruction = receiveIntentToTransactionInstruction;
+exports.selectForwarderFee = selectForwarderFee;
+exports.starknetFeltToString = feltToString;
+exports.stellarBurnDust = stellarBurnDust;
+exports.stellarSubunitsToCanonical = stellarSubunitsToCanonical;
+exports.strkeyTo32Bytes = strkeyTo32Bytes;
+exports.strkeyType = strkeyType;
+exports.toBytes32 = toBytes32;
+exports.tokenMessengerV2Abi = tokenMessengerV2Abi;
+exports.tokenMessengerWithFeesAbi = tokenMessengerWithFeesAbi;
+exports.tryChainByEvmChainId = tryChainByEvmChainId;
+exports.tryFromBytes32 = tryFromBytes32;
+exports.u256ToFelts = u256ToFelts;
+exports.usdcAbi = usdcAbi;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map