@usewhisk/cctp 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,3785 @@
+import { Asset, TransactionBuilder, Account, BASE_FEE, Contract, nativeToScVal, StrKey, Address, scValToNative, xdr } from '@stellar/stellar-sdk';
+import { hash, cairo, num } from 'starknet';
+import { encodeFunctionData } from 'viem';
+import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
+import { sha256 } from '@noble/hashes/sha256';
+import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { Buffer as Buffer$1 } from '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 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 = 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 TransactionBuilder(new Account(chain.usdcIssuer, "0"), {
+    fee: BASE_FEE,
+    networkPassphrase: chain.networkPassphrase
+  }).addOperation(
+    new Contract(chain.messageTransmitter).call(
+      "is_nonce_used",
+      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 = scValToNative(xdr.ScVal.fromXDR(value, "base64"));
+      return typeof used === "boolean" ? used : void 0;
+    },
+    options
+  );
+}
+
+// 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 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 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: 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 ? encodeFunctionData({
+      abi: tokenMessengerV2Abi,
+      functionName: "depositForBurnWithHook",
+      args: [...burnArgs, effectiveHookData]
+    }) : 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: encodeFunctionData({
+        abi: usdcAbi,
+        functionName: "approve",
+        args: [source.tokenMessengerWithFees, approveAmount]
+      }),
+      value: 0n
+    },
+    {
+      to: source.tokenMessengerWithFees,
+      data: 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 = 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 = cairo.uint256(value);
+  return [u.low.toString(), u.high.toString()];
+}
+function feltToString(value) {
+  return 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 StrKey.isValidEd25519PublicKey(s2) || StrKey.isValidMed25519PublicKey(s2) || StrKey.isValidContract(s2);
+}
+function strkeyType(s2) {
+  if (StrKey.isValidEd25519PublicKey(s2)) return "G";
+  if (StrKey.isValidMed25519PublicKey(s2)) return "M";
+  if (StrKey.isValidContract(s2)) return "C";
+  throw new InvalidInputError(
+    "invalid_address",
+    `Invalid Stellar strkey: ${s2}`
+  );
+}
+function decodeStrkeyToBytes32(s2) {
+  if (StrKey.isValidEd25519PublicKey(s2))
+    return StrKey.decodeEd25519PublicKey(s2);
+  if (StrKey.isValidContract(s2)) return StrKey.decodeContract(s2);
+  if (StrKey.isValidMed25519PublicKey(s2)) {
+    return 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 StrKey.encodeContract(Buffer.from(bytes));
+}
+function contractStrkeyToBytes32Hex(s2) {
+  if (!StrKey.isValidContract(s2)) {
+    throw new InvalidInputError(
+      "invalid_address",
+      `Not a Stellar contract strkey (C\u2026): ${s2}`
+    );
+  }
+  const bytes = 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 Address(input.owner).toScVal(),
+    new Address(input.spender).toScVal(),
+    nativeToScVal(input.amount, { type: "i128" }),
+    nativeToScVal(input.expirationLedger, { type: "u32" })
+  ];
+  const operation = new 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 Address(input.caller).toScVal(),
+    nativeToScVal(input.amount, { type: "i128" }),
+    nativeToScVal(input.destinationDomain, { type: "u32" }),
+    nativeToScVal(Buffer.from(input.mintRecipientBytes32), {
+      type: "bytes"
+    }),
+    new Address(usdcSac).toScVal(),
+    nativeToScVal(Buffer.from(input.destinationCallerBytes32), {
+      type: "bytes"
+    }),
+    nativeToScVal(input.maxFee, { type: "i128" }),
+    nativeToScVal(input.minFinalityThreshold, { type: "u32" })
+  ];
+  if (withHook) {
+    args.push(nativeToScVal(Buffer.from(input.hookData), { type: "bytes" }));
+  }
+  const operation = new 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 = [
+    nativeToScVal(Buffer.from(input.message), { type: "bytes" }),
+    nativeToScVal(Buffer.from(input.attestation), { type: "bytes" })
+  ];
+  const operation = new 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 PublicKey.findProgramAddressSync(
+    [SEEDS.tokenMessenger],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveTokenMinter(tokenMessengerMinterProgram) {
+  return PublicKey.findProgramAddressSync(
+    [SEEDS.tokenMinter],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveSenderAuthority(tokenMessengerMinterProgram) {
+  return PublicKey.findProgramAddressSync(
+    [SEEDS.senderAuthority],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveRemoteTokenMessenger(tokenMessengerMinterProgram, domain) {
+  return PublicKey.findProgramAddressSync(
+    [SEEDS.remoteTokenMessenger, enc.encode(domain.toString())],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveLocalToken(tokenMessengerMinterProgram, mint) {
+  return 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 PublicKey.findProgramAddressSync(
+    [SEEDS.tokenPair, enc.encode(sourceDomain.toString()), sourceTokenBytes32],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveCustodyTokenAccount(tokenMessengerMinterProgram, mint) {
+  return PublicKey.findProgramAddressSync(
+    [SEEDS.custody, mint.toBytes()],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveDenylistAccount(tokenMessengerMinterProgram, owner) {
+  return PublicKey.findProgramAddressSync(
+    [SEEDS.denylistAccount, owner.toBytes()],
+    tokenMessengerMinterProgram
+  )[0];
+}
+function deriveMessageTransmitter(messageTransmitterProgram) {
+  return PublicKey.findProgramAddressSync(
+    [SEEDS.messageTransmitter],
+    messageTransmitterProgram
+  )[0];
+}
+function deriveMessageTransmitterAuthority(messageTransmitterProgram, receiverProgram) {
+  return 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 PublicKey.findProgramAddressSync(
+    [SEEDS.usedNonce, nonce],
+    messageTransmitterProgram
+  )[0];
+}
+function deriveEventAuthority(programId) {
+  return PublicKey.findProgramAddressSync([SEEDS.eventAuthority], programId)[0];
+}
+function anchorDiscriminator(snakeCaseName) {
+  const bytes = new TextEncoder().encode(`global:${snakeCaseName}`);
+  return 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$1.alloc(initialSize), offset: 0 };
+}
+function ensure(w, extra) {
+  if (w.offset + extra <= w.buf.length) return;
+  const next = Buffer$1.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$1.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 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 PublicKey(input.source.tokenMessengerMinter);
+  const mtProgram = new PublicKey(input.source.messageTransmitter);
+  const burnTokenMint = new 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: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: 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 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 PublicKey(input.destination.tokenMessengerMinter);
+  const mtProgram = new PublicKey(input.destination.messageTransmitter);
+  const localMint = new 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: 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: 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 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 PublicKey(
+    accountData.slice(FEE_RECIPIENT_OFFSET, FEE_RECIPIENT_END)
+  );
+}
+
+// src/index.ts
+var VERSION2 = "0.1.0";
+
+export { ANY_DESTINATION_CALLER, Arbitrum, ArbitrumSepolia, Arc, ArcTestnet, Avalanche, AvalancheFuji, Base, BaseSepolia, CCTP_FORWARDER_STELLAR_MAINNET, CCTP_FORWARDER_STELLAR_TESTNET, CCTP_FORWARD_HOOK_DATA, CCTP_FORWARD_HOOK_DATA_LENGTH, CCTP_USDC_DECIMALS, CHAINS, CctpError, Codex, CodexTestnet, Cronos, CronosTestnet, DISCRIMINATOR_DEPOSIT_FOR_BURN, DISCRIMINATOR_DEPOSIT_FOR_BURN_WITH_HOOK, DISCRIMINATOR_RECEIVE_MESSAGE, EVM_MAINNET_CHAINS, EVM_TESTNET_CHAINS, Edge, EdgeTestnet, Ethereum, EthereumSepolia, FINALITY_FAST, FINALITY_STANDARD, HyperEVM, HyperEVMTestnet, IRIS_MAINNET_URL, IRIS_SANDBOX_URL, Injective, InjectiveTestnet, Ink, InkTestnet, InvalidAddressError, InvalidBytes32Error, InvalidInputError, IrisAbortedError, IrisError, IrisHttpError, IrisNetworkError, IrisParseError, IrisRateLimitedError, Linea, LineaSepolia, MESSAGE_TRANSMITTER_STELLAR_MAINNET, MESSAGE_TRANSMITTER_STELLAR_TESTNET, MESSAGE_TRANSMITTER_V2_EVM_MAINNET, MESSAGE_TRANSMITTER_V2_EVM_TESTNET, MESSAGE_TRANSMITTER_V2_SOLANA, MESSAGE_TRANSMITTER_V2_STARKNET_MAINNET, MESSAGE_TRANSMITTER_V2_STARKNET_SEPOLIA, Monad, MonadTestnet, Morph, MorphTestnet, Optimism, OptimismSepolia, Pharos, PharosTestnet, Plasma, PlasmaTestnet, Plume, PlumeTestnet, Polygon, PolygonAmoyTestnet, ProtocolError, ANY_DESTINATION_CALLER2 as SOLANA_ANY_DESTINATION_CALLER, SOLANA_CCTP_DOMAIN, SEEDS as SOLANA_CCTP_PDA_SEEDS, STARKNET_CCTP_DOMAIN, STARKNET_CHAIN_ID_MAINNET, STARKNET_CHAIN_ID_SEPOLIA, STELLAR_CCTP_DOMAIN, STELLAR_NETWORK_PASSPHRASE_MAINNET, STELLAR_NETWORK_PASSPHRASE_TESTNET, STELLAR_USDC_DECIMALS, Sei, SeiTestnet, Solana, SolanaDevnet, Sonic, SonicTestnet, Starknet, StarknetSepolia, Stellar, StellarTestnet, TOKEN_MESSENGER_MINTER_STELLAR_MAINNET, TOKEN_MESSENGER_MINTER_STELLAR_TESTNET, TOKEN_MESSENGER_MINTER_V2_SOLANA, TOKEN_MESSENGER_MINTER_V2_STARKNET_MAINNET, TOKEN_MESSENGER_MINTER_V2_STARKNET_SEPOLIA, TOKEN_MESSENGER_V2_EVM_MAINNET, TOKEN_MESSENGER_V2_EVM_TESTNET, TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET, TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET, USDC_ISSUER_STELLAR_MAINNET, USDC_ISSUER_STELLAR_TESTNET, USDC_SPL_DEVNET, USDC_SPL_MAINNET, USDC_STARKNET_MAINNET, USDC_STARKNET_SEPOLIA, Unichain, UnichainSepolia, UnknownChainError, UnsupportedError, VERSION2 as VERSION, WorldChain, WorldChainSepolia, XDC, XDCApothem, XLayer, XLayerTestnet, anchorDiscriminator, assertStarknetFelt, attestationSeconds, buildBurnIntent, buildBurnWithFeesIntent, buildForwarderHookData, buildMintIntent, buildSolanaBurnIntent, buildSolanaReceiveIntent, buildStarknetApproveCall, buildStarknetBurnIntent, buildStarknetReceiveIntent, buildStellarApproveInvocation, buildStellarBurnIntent, buildStellarForwarderHookData, buildStellarMintIntent, burnIntentToTransactionInstruction, bytes32HexToFelt, bytesToByteArrayFelts, canonicalToStellarSubunits, chainByDomain, chainByEvmChainId, chainsByNetwork, computeBurnFee, computeMaxFee, contractStrkeyToBytes32Hex, createIrisLimiter, decodeBurnMessage, decodeStrkeyToBytes32, defaultIrisLimiter, deriveCustodyTokenAccount, deriveDenylistAccount, deriveEventAuthority, deriveLocalToken, deriveMessageTransmitter, deriveMessageTransmitterAuthority, deriveRemoteTokenMessenger, deriveSenderAuthority, deriveTokenMessenger, deriveTokenMinter, deriveTokenPair, deriveUsedNonce, encodeContractStrkey, explorerAddressUrl, explorerTxUrl, feltToBigInt, feltToBytes32Hex, fetchIrisJson, fromBytes32, getBlockNumber, getBurnFees, getChain, getFastBurnAllowance, getGasPrice, getMessages, getSignedBurnQuote, getStandardMinFee, getStarknetTransactionStatus, getTransactionStatus, getUsdcBalance, hexToByteArrayFelts, irisBaseUrl, isAddress, isCctpError, isChainId, isEvmChain, isForwardDone, isForwarderHookData, isNonceUsed, isSolanaChain, isStarknetChain, isStarknetNonceUsed, isStellarChain, isStellarNonceUsed, isValidStarknetFelt, isValidStellarStrkey, messageTransmitterV2Abi, parseFeeBps, parseForwarderFee, parseTokenMessengerFeeRecipient, pickFeeTier, pickForwarderFee, pollBudget, pollMessages, reattest, receiveIntentToTransactionInstruction, selectForwarderFee, feltToString as starknetFeltToString, stellarBurnDust, stellarSubunitsToCanonical, strkeyTo32Bytes, strkeyType, toBytes32, tokenMessengerV2Abi, tokenMessengerWithFeesAbi, tryChainByEvmChainId, tryFromBytes32, u256ToFelts, usdcAbi };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map