@usewhisk/cctp 0.0.0 → 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,940 @@
+import { I as InvalidInputError } from './index-BIerSvES.cjs';
+export { A as Arbitrum, a as ArbitrumSepolia, b as Arc, c as ArcTestnet, d as Avalanche, e as AvalancheFuji, B as Base, f as BaseSepolia, C as CCTP_FORWARDER_STELLAR_MAINNET, g as CCTP_FORWARDER_STELLAR_TESTNET, h as CCTP_USDC_DECIMALS, i as CHAINS, j as CctpError, k as CctpErrorCode, l as ChainId, m as Codex, n as CodexTestnet, o as Cronos, p as CronosTestnet, E as EVM_MAINNET_CHAINS, q as EVM_TESTNET_CHAINS, r as Edge, s as EdgeTestnet, t as Ethereum, u as EthereumSepolia, H as HyperEVM, v as HyperEVMTestnet, w as Injective, x as InjectiveTestnet, y as Ink, z as InkTestnet, D as IrisAbortedError, F as IrisError, G as IrisHttpError, J as IrisNetworkError, K as IrisParseError, L as IrisRateLimitedError, M as Linea, N as LineaSepolia, O as MESSAGE_TRANSMITTER_STELLAR_MAINNET, P as MESSAGE_TRANSMITTER_STELLAR_TESTNET, Q as MESSAGE_TRANSMITTER_V2_EVM_MAINNET, R as MESSAGE_TRANSMITTER_V2_EVM_TESTNET, S as MESSAGE_TRANSMITTER_V2_SOLANA, T as MESSAGE_TRANSMITTER_V2_STARKNET_MAINNET, U as MESSAGE_TRANSMITTER_V2_STARKNET_SEPOLIA, V as Monad, W as MonadTestnet, X as Morph, Y as MorphTestnet, Z as Optimism, _ as OptimismSepolia, $ as Pharos, a0 as PharosTestnet, a1 as Plasma, a2 as PlasmaTestnet, a3 as Plume, a4 as PlumeTestnet, a5 as Polygon, a6 as PolygonAmoyTestnet, a7 as ProtocolError, a8 as SOLANA_CCTP_DOMAIN, a9 as STARKNET_CCTP_DOMAIN, aa as STARKNET_CHAIN_ID_MAINNET, ab as STARKNET_CHAIN_ID_SEPOLIA, ac as STELLAR_CCTP_DOMAIN, ad as STELLAR_NETWORK_PASSPHRASE_MAINNET, ae as STELLAR_NETWORK_PASSPHRASE_TESTNET, af as STELLAR_USDC_DECIMALS, ag as Sei, ah as SeiTestnet, ai as Solana, aj as SolanaDevnet, ak as Sonic, al as SonicTestnet, am as Starknet, an as StarknetSepolia, ao as Stellar, ap as StellarTestnet, aq as TOKEN_MESSENGER_MINTER_STELLAR_MAINNET, ar as TOKEN_MESSENGER_MINTER_STELLAR_TESTNET, as as TOKEN_MESSENGER_MINTER_V2_SOLANA, at as TOKEN_MESSENGER_MINTER_V2_STARKNET_MAINNET, au as TOKEN_MESSENGER_MINTER_V2_STARKNET_SEPOLIA, av as TOKEN_MESSENGER_V2_EVM_MAINNET, aw as TOKEN_MESSENGER_V2_EVM_TESTNET, ax as TOKEN_MESSENGER_WITH_FEES_EVM_MAINNET, ay as TOKEN_MESSENGER_WITH_FEES_EVM_TESTNET, az as USDC_ISSUER_STELLAR_MAINNET, aA as USDC_ISSUER_STELLAR_TESTNET, aB as USDC_SPL_DEVNET, aC as USDC_SPL_MAINNET, aD as USDC_STARKNET_MAINNET, aE as USDC_STARKNET_SEPOLIA, aF as Unichain, aG as UnichainSepolia, aH as UnknownChainError, aI as UnsupportedError, aJ as WorldChain, aK as WorldChainSepolia, aL as XDC, aM as XDCApothem, aN as XLayer, aO as XLayerTestnet, aP as chainByDomain, aQ as chainByEvmChainId, aR as chainsByNetwork, aS as explorerAddressUrl, aT as explorerTxUrl, aU as getChain, aV as isCctpError, aW as isChainId, aX as isEvmChain, aY as isSolanaChain, aZ as isStarknetChain, a_ as isStellarChain, a$ as tryChainByEvmChainId } from './index-BIerSvES.cjs';
+import { E as EvmChain, S as StarknetChain, a as StellarChain, A as Address, B as BurnFeeTier, F as ForwarderFeeTier, C as CctpChain, b as FinalityThreshold, c as StarknetFelt, d as SolanaChain } from './attestation-D52iUV0y.cjs';
+export { e as CctpDomain, f as ChainCapabilities, g as Ecosystem, h as EvmChainId, i as FINALITY_FAST, j as FINALITY_STANDARD, k as ForwardState, G as GetMessagesQuery, I as IrisAttestationStatus, l as IrisDelayReason, m as IrisMessage, n as IrisMessagesResponse, N as Network, o as SecondsRange, p as SolanaCluster, q as SolanaPubkey, r as StarknetNetwork, s as StellarNetwork, t as StellarStrkey, T as TransferSpeed, u as attestationSeconds } from './attestation-D52iUV0y.cjs';
+export { messageTransmitterV2Abi, tokenMessengerV2Abi, tokenMessengerWithFeesAbi, usdcAbi } from './abi.cjs';
+export { FetchJsonOptions, GetBurnFeesOptions, GetMessagesOptions, IRIS_MAINNET_URL, IRIS_SANDBOX_URL, IrisLimiter, IrisLimiterOptions, PollMessageOptions, ReattestOptions, SignedBurnQuote, SignedBurnQuoteRequest, SignedQuoteExpiry, UpfrontFeeType, createIrisLimiter, defaultIrisLimiter, fetchIrisJson, getBurnFees, getFastBurnAllowance, getMessages, getSignedBurnQuote, irisBaseUrl, isForwardDone, pickFeeTier, pickForwarderFee, pollBudget, pollMessages, reattest } from './iris.cjs';
+import { xdr } from '@stellar/stellar-sdk';
+import { PublicKey, AccountMeta, TransactionInstruction } from '@solana/web3.js';
+
+type RpcOptions = {
+    /** Tried in order before the chain's default RPCs. */
+    rpcUrls?: readonly string[];
+    fetch?: typeof fetch;
+};
+/** `eth_gasPrice`, in wei. */
+declare function getGasPrice(chain: EvmChain, options?: RpcOptions): Promise<bigint>;
+declare function getBlockNumber(chain: EvmChain, options?: RpcOptions): Promise<bigint>;
+/**
+ * Whether `MessageTransmitterV2.usedNonces(nonce)` is set: the message was
+ * already received on this chain and minting it again would revert.
+ */
+declare function isNonceUsed(chain: EvmChain, nonce: `0x${string}`, options?: RpcOptions): Promise<boolean>;
+type TransactionStatus = "success" | "reverted" | "unknown";
+/** `unknown` until the transaction is mined, or if the node never saw it. */
+declare function getTransactionStatus(chain: EvmChain, hash: `0x${string}`, options?: RpcOptions): Promise<TransactionStatus>;
+/** The USDC ERC-20 balance of `owner`, in subunits. */
+declare function getUsdcBalance(chain: EvmChain, owner: `0x${string}`, options?: RpcOptions): Promise<bigint>;
+
+/** `MessageTransmitter.is_nonce_used(u256)` on Starknet. */
+declare function isStarknetNonceUsed(chain: StarknetChain, nonce: `0x${string}`, options?: RpcOptions): Promise<boolean>;
+/**
+ * `MessageTransmitter.is_nonce_used(BytesN<32>)` on Stellar, read by
+ * simulating the call. Simulation needs a source account but no signature,
+ * so the USDC issuer, which always exists, stands in.
+ */
+declare function isStellarNonceUsed(chain: StellarChain, nonce: `0x${string}`, options?: RpcOptions): Promise<boolean>;
+
+/** `pending` until the sequencer has accepted the transaction on L2. */
+type StarknetTransactionStatus = {
+    state: "pending";
+} | {
+    state: "success" | "reverted";
+    blockNumber: number;
+};
+/**
+ * Reads the receipt over plain JSON-RPC. starknet.js refuses nodes on a spec
+ * version it does not know, and public nodes move ahead of it, so the
+ * receipt is read here instead. The fields used are the same from 0.8 to 0.10.
+ */
+declare function getStarknetTransactionStatus(chain: StarknetChain, hash: string, options?: RpcOptions): Promise<StarknetTransactionStatus>;
+
+/**
+ * Forwarder hookData.
+ *
+ * Including this 32-byte hookData in `depositForBurnWithHook` tells
+ * Circle's Orbit relayer to fetch the attestation and submit the
+ * destination mint on the user's behalf.
+ *
+ * Layout:
+ *   bytes  0..11: ASCII "cctp-forward"
+ *   bytes 12..23: zero pad
+ *   bytes 24..27: uint32 BE version (0)
+ *   bytes 28..31: uint32 BE payload length (0 for basic forwarding)
+ */
+/** Static hex string used for every Whisk bridge with forwarder enabled. */
+declare const CCTP_FORWARD_HOOK_DATA: `0x${string}`;
+declare const CCTP_FORWARD_HOOK_DATA_LENGTH = 32;
+/**
+ * Encodes the same bytes as `CCTP_FORWARD_HOOK_DATA` field by field. Stellar
+ * destinations need a payload and use `buildStellarForwarderHookData`.
+ */
+declare function buildForwarderHookData(): `0x${string}`;
+/** True when `hex` starts with the 32-byte basic forwarder hookData. */
+declare function isForwarderHookData(hex: string): boolean;
+/** bytes32(0) as `destinationCaller` lets anyone submit the mint. */
+declare const ANY_DESTINATION_CALLER$1: `0x${string}`;
+
+/**
+ * Address encoding for CCTP message fields.
+ *
+ * CCTP uses 32-byte (`bytes32`) values for `mintRecipient` and
+ * `destinationCaller` so it can carry both 20-byte EVM addresses and
+ * 32-byte non-EVM addresses. The encoders here are EVM only.
+ */
+
+declare class InvalidAddressError extends InvalidInputError {
+    constructor(input: string);
+}
+declare class InvalidBytes32Error extends InvalidInputError {
+    constructor(input: string);
+}
+/**
+ * Left-pad a 20-byte EVM address to 32 bytes for use as a CCTP
+ * `bytes32` field.
+ *
+ *   0xabcd...1234  →  0x000000000000000000000000abcd...1234
+ *
+ * Output is lowercase; `getAddress(fromBytes32(value))` restores the
+ * checksum.
+ */
+declare function toBytes32(address: Address | string): `0x${string}`;
+/**
+ * Reverse of `toBytes32`. Strips the 12-byte zero pad and returns a
+ * lowercase 20-byte address.
+ *
+ * Throws if the upper 12 bytes are not zero (i.e. the value isn't an
+ * EVM address). Callers can use `tryFromBytes32` for a non-throwing
+ * variant.
+ */
+declare function fromBytes32(value: `0x${string}` | string): Address;
+declare function tryFromBytes32(value: string): Address | undefined;
+declare function isAddress(value: string): value is Address;
+
+/**
+ * Fee math for CCTP V2 bridges.
+ *
+ * Two protocol-level fees stack on a Fast Transfer + Forwarder bridge:
+ *
+ *   1. Burn fee: a rate on the transfer amount, charged by CCTP. Iris
+ *      returns `minimumFee` in basis points with up to two decimals
+ *      (`1.3` is 0.013%). Whisk holds it as hundredths of a basis
+ *      point, so `1.3` becomes `130n`.
+ *
+ *   2. Forwarder fee: a flat USDC fee that pays for destination gas
+ *      and the relayer. Iris returns low, med and high levels in USDC
+ *      subunits. Whisk defaults to `med`.
+ *
+ * `maxFee` on `depositForBurnWithHook` must cover both. Every step
+ * rounds up: a `maxFee` one subunit short turns a Fast transfer into a
+ * Standard one.
+ */
+
+/** Iris's `minimumFee` as hundredths of a basis point: `1.3` is `130n`. */
+declare function parseFeeBps(raw: unknown): bigint;
+/** An Iris forwarder fee in USDC subunits, rounded up. */
+declare function parseForwarderFee(raw: unknown): bigint;
+/**
+ * The CCTP burn fee on `amount` subunits at `feeCentiBps` hundredths of
+ * a basis point, rounded up.
+ */
+declare function computeBurnFee(amount: bigint, feeCentiBps: bigint): bigint;
+/** The forwarder fee for a level, in USDC subunits. */
+declare function selectForwarderFee(tier: BurnFeeTier, level?: keyof ForwarderFeeTier): bigint;
+type ComputeMaxFeeInput = {
+    /** Transfer amount in USDC subunits. */
+    amount: bigint;
+    /** Selected tier (Fast or Standard). */
+    tier: BurnFeeTier;
+    /** Forwarder fee level; defaults to `"med"`. */
+    forwarderLevel?: keyof ForwarderFeeTier;
+    /**
+     * Whole basis points added to the forwarder fee (0 to 10000). Iris's
+     * `high` level already carries a buffer, so this defaults to 0.
+     */
+    forwarderBufferBps?: number;
+    /** Whether to include the forwarder fee. Defaults to `true`. */
+    includeForwarder?: boolean;
+    /**
+     * Whole basis points added to the protocol fee in `maxFee` only. Circle
+     * takes the fee it executes, so the buffer is a ceiling, not a charge.
+     */
+    burnFeeBufferBps?: number;
+    /** The on-chain minimum from `getMinFeeAmount`, in USDC subunits. */
+    minBurnFee?: bigint;
+};
+type ComputeMaxFeeResult = {
+    /** The protocol fee, raised to `minBurnFee` if lower, before any buffer. */
+    burnFee: bigint;
+    forwarderFee: bigint;
+    /** Total cap to pass as `maxFee` on `depositForBurnWithHook`. */
+    maxFee: bigint;
+};
+/**
+ *   maxFee = burnFee (+ buffer) + forwarderFee (+ buffer)
+ *
+ * The result is a cap; the actual deducted fee can be less.
+ */
+declare function computeMaxFee(input: ComputeMaxFeeInput): ComputeMaxFeeResult;
+
+type GetStandardMinFeeOptions = RpcOptions;
+/**
+ * `TokenMessengerV2.getMinFeeAmount(amount)`: the least `maxFee` a Standard
+ * burn of `amount` may carry on a chain with Circle's fee switch.
+ */
+declare function getStandardMinFee(chain: EvmChain, amount: bigint, options?: GetStandardMinFeeOptions): Promise<bigint>;
+
+/** A CCTP V2 message carrying a burn, read from the attested bytes. */
+type DecodedBurnMessage = {
+    version: number;
+    sourceDomain: number;
+    destinationDomain: number;
+    nonce: `0x${string}`;
+    sender: `0x${string}`;
+    recipient: `0x${string}`;
+    destinationCaller: `0x${string}`;
+    minFinalityThreshold: number;
+    finalityThresholdExecuted: number;
+    body: {
+        version: number;
+        burnToken: `0x${string}`;
+        mintRecipient: `0x${string}`;
+        amount: bigint;
+        messageSender: `0x${string}`;
+        maxFee: bigint;
+        feeExecuted: bigint;
+        /** In the destination chain's own height; `0n` once finalized. */
+        expirationBlock: bigint;
+        hookData: `0x${string}`;
+    };
+};
+/**
+ * Splits a message into its fields. Every address is the 32-byte form CCTP
+ * carries; an EVM address is its last 20 bytes.
+ */
+declare function decodeBurnMessage(message: `0x${string}`): DecodedBurnMessage;
+
+/**
+ * A burn intent is the chain-bound call(s) the wallet adapter signs
+ * and submits. It contains no transaction-level data (gas, nonce);
+ * the adapter fills those in.
+ */
+
+/**
+ * One on-chain call. A bridge is usually an `approve` followed by the burn;
+ * the wallet adapter may batch them via EIP-5792 when supported.
+ */
+type EvmCall = {
+    to: Address;
+    data: `0x${string}`;
+    /** Always `0n`: USDC burns carry no native value. */
+    value: bigint;
+};
+type BurnIntent = {
+    source: CctpChain;
+    destination: CctpChain;
+    /** Executed in order. */
+    calls: EvmCall[];
+    /** USDC subunits, 6 decimals. */
+    amount: bigint;
+    /** `maxFee` cap that was packed into the burn call. */
+    maxFee: bigint;
+    /** Computed protocol fee, for a fee breakdown. */
+    burnFee: bigint;
+    /** Computed forwarder fee. `0n` when the forwarder is off. */
+    forwarderFee: bigint;
+    mintRecipientBytes32: `0x${string}`;
+    /** Whether the burn call set `hookData` for Forwarder use. */
+    withForwarder: boolean;
+    finalityThreshold: FinalityThreshold;
+};
+
+type BuildBurnIntentInput = {
+    source: CctpChain;
+    destination: CctpChain;
+    /** USDC subunits (6 decimals). Must be > 0 and ≤ 10M USDC. */
+    amount: bigint;
+    /**
+     * Recipient in the destination's format: a 20-byte EVM address, a base58
+     * Solana pubkey, or 0x-prefixed 32-byte hex for Stellar and Starknet.
+     */
+    mintRecipient: Address | string;
+    /**
+     * Restrict who can call `receiveMessage` on the destination. Defaults
+     * to `bytes32(0)` (any caller) so the forwarder can mint without
+     * extra coordination. Pass a specific 32-byte value if you need to
+     * lock the mint down.
+     */
+    destinationCaller?: `0x${string}`;
+    /**
+     * Approve allowance to set on USDC. Defaults to `amount`. Set higher
+     * to skip the approve call across multiple bridges (allowance
+     * caching).
+     */
+    approveAmount?: bigint;
+    /**
+     * If `true`, skip the approve call entirely (the wallet already has
+     * sufficient allowance). Defaults to `false`.
+     */
+    skipApprove?: boolean;
+    /**
+     * Trigger Circle's Orbit forwarder by including the
+     * `cctp-forward` hookData. Defaults to `true`. Set to `false` to
+     * make the user mint manually on the destination chain.
+     */
+    withForwarder?: boolean;
+    /**
+     * Override the hookData. When `withForwarder` is true and this is
+     * unset, the EVM-side `cctp-forward` magic bytes are used (Circle's
+     * Orbit relayer). For Stellar destinations, pass the Stellar
+     * `CctpForwarder` hookData instead. The EVM relayer is irrelevant
+     * because the Stellar Forwarder is what reads this field on chain.
+     */
+    customHookData?: `0x${string}`;
+    /** Fee math inputs. See `computeMaxFee`. */
+    fee: Pick<ComputeMaxFeeInput, "tier" | "forwarderLevel" | "forwarderBufferBps"> & {
+        /**
+         * Burn with exactly this cap instead of one computed from the tier. Pass
+         * the `maxFee` the payer confirmed.
+         */
+        maxFee?: bigint;
+    };
+};
+declare function buildBurnIntent(input: BuildBurnIntentInput): BurnIntent;
+
+type BuildBurnWithFeesIntentInput = {
+    source: CctpChain;
+    destination: CctpChain;
+    /** Exactly the amount the signed quote was requested for. */
+    amount: bigint;
+    /** The quote's USDC fee, collected by the contract on top of `amount`. */
+    fee: bigint;
+    mintRecipient: Address | string;
+    signedQuote: `0x${string}`;
+    /** Reserved by Circle for refunds it does not make today. */
+    refundAddress: Address | string;
+    /** Defaults to `amount + fee`. */
+    approveAmount?: bigint;
+};
+type BurnWithFeesIntent = {
+    calls: EvmCall[];
+    amount: bigint;
+    fee: bigint;
+    mintRecipientBytes32: `0x${string}`;
+};
+/**
+ * Approve and `depositForBurnWithFees` calls for a burn whose Fast and
+ * forwarding fees were paid upfront from a signed quote. The contract adds
+ * Circle's forwarding hook itself when the quote includes a `FORWARD` fee.
+ */
+declare function buildBurnWithFeesIntent(input: BuildBurnWithFeesIntentInput): BurnWithFeesIntent;
+
+type MintIntent = {
+    destination: CctpChain;
+    call: EvmCall;
+};
+type BuildMintIntentInput = {
+    destination: CctpChain;
+    /** Raw 0x-prefixed CCTP message bytes from Iris. */
+    message: `0x${string}`;
+    /** Raw 0x-prefixed attestation bytes from Iris. */
+    attestation: `0x${string}`;
+};
+/**
+ * `receiveMessage` on the destination's `MessageTransmitterV2`. EVM
+ * destinations only. Whoever submits the call pays destination gas.
+ */
+declare function buildMintIntent(input: BuildMintIntentInput): MintIntent;
+
+/**
+ * Starknet address / mintRecipient helpers.
+ *
+ * Starknet uses 252-bit field elements, but CCTP messages carry 32-byte
+ * `mintRecipient` / `destinationCaller` fields. Whisk normalizes to two
+ * forms:
+ *
+ *   - bytes32 hex (`0x` + 64 hex): what other ecosystems pack into the
+ *     CCTP message envelope.
+ *   - u256 bigint: what Starknet's `deposit_for_burn` expects in
+ *     calldata.
+ *
+ * Conversion is just zero-extending the felt to 32 bytes or reading the
+ * bigint back from it.
+ */
+
+declare function isValidStarknetFelt(s: string): boolean;
+/** Throws on a malformed felt. */
+declare function assertStarknetFelt(s: string): StarknetFelt;
+/**
+ * Zero-pads a felt to 0x-prefixed 32-byte hex. Used for `mintRecipient`
+ * when bridging to Starknet from another ecosystem.
+ */
+declare function feltToBytes32Hex(felt: StarknetFelt): `0x${string}`;
+/** Leading zeros are stripped. */
+declare function bytes32HexToFelt(hex: `0x${string}` | string): StarknetFelt;
+/** For packing into u256 calldata args. */
+declare function feltToBigInt(felt: StarknetFelt): bigint;
+
+/** Encode a u256 as `[lo, hi]` felt strings (decimal). */
+declare function u256ToFelts(value: bigint): [string, string];
+/** Encode a u32 / u64 / felt252 as a single felt string (decimal). */
+declare function feltToString(value: number | bigint | string): string;
+/**
+ * Encode a `ByteArray` from raw bytes.
+ *
+ * Cairo `ByteArray` calldata serialization:
+ *
+ *   [ data.length: u32,
+ *     ...data: felt252 (31 bytes each, big-endian),
+ *     pending_word: felt252 (< 31 bytes, big-endian),
+ *     pending_word_len: u32 ]
+ *
+ * Each 31-byte block becomes one felt whose value is the big-endian
+ * integer of those bytes. The trailing (bytes.length % 31) bytes go
+ * into `pending_word`, again as a big-endian integer of exactly that
+ * many bytes.
+ *
+ * starknet.js's `byteArray.byteArrayFromString` is no substitute: it
+ * treats the input as a UTF-8 string, which mangles raw bytes like
+ * CCTP attestation blobs.
+ */
+declare function bytesToByteArrayFelts(bytes: Uint8Array): string[];
+/** Encode a 0x-prefixed hex blob (any length) as a Cairo ByteArray. */
+declare function hexToByteArrayFelts(hex: string): string[];
+
+/**
+ * Starknet CCTP V2 `deposit_for_burn` / `deposit_for_burn_with_hook`
+ * Call builder.
+ *
+ * Cairo signatures (from `circlefin/starknet-cctp`):
+ *
+ *   fn deposit_for_burn(
+ *     amount: u256,
+ *     destination_domain: u32,
+ *     mint_recipient: u256,
+ *     burn_token: ContractAddress,
+ *     destination_caller: u256,
+ *     max_fee: u256,
+ *     min_finality_threshold: u32,
+ *   )
+ *
+ *   fn deposit_for_burn_with_hook(
+ *     ...same...
+ *     hook_data: ByteArray,
+ *   )
+ *
+ * USDC on Starknet behaves like ERC-20: burn pulls funds via
+ * `transferFrom`, so the caller must `approve(TMM, amount)` first with
+ * `buildStarknetApproveCall`.
+ */
+
+type StarknetCall = {
+    contractAddress: StarknetFelt;
+    /** Cairo function name (snake_case). */
+    entrypoint: string;
+    /** Pre-serialized calldata as a flat felt array (decimal strings). */
+    calldata: string[];
+};
+type BuildStarknetBurnIntentInput = {
+    source: StarknetChain;
+    destinationDomain: number;
+    /** USDC subunits (6 decimals), the canonical CCTP amount. */
+    amount: bigint;
+    /** `maxFee` cap in 6-decimal subunits. */
+    maxFee: bigint;
+    /**
+     * 32-byte mintRecipient, packed by Starknet into a single u256. The
+     * caller is responsible for encoding correctly:
+     *   - EVM     20-byte address left-padded to 32 bytes
+     *   - Solana  recipient USDC ATA pubkey (32 bytes raw)
+     *   - Stellar CctpForwarder strkey decoded to 32 bytes
+     *   - Starknet contract felt
+     */
+    mintRecipient: bigint;
+    /** `destinationCaller` u256. Zero = any caller. */
+    destinationCaller: bigint;
+    /** Optional hookData; when set, builds `deposit_for_burn_with_hook`. */
+    hookData?: Uint8Array;
+    /** Take it from the fee tier. */
+    minFinalityThreshold: FinalityThreshold;
+};
+type StarknetBurnIntent = {
+    source: StarknetChain;
+    destinationDomain: number;
+    amount: bigint;
+    maxFee: bigint;
+    call: StarknetCall;
+    withHook: boolean;
+};
+declare function buildStarknetBurnIntent(input: BuildStarknetBurnIntentInput): StarknetBurnIntent;
+/**
+ * Starknet's USDC follows the standard ERC-20 / SNIP-2 interface:
+ * `approve(spender, amount: u256)`.
+ */
+declare function buildStarknetApproveCall(args: {
+    source: StarknetChain;
+    spender: StarknetFelt;
+    amount: bigint;
+}): StarknetCall;
+
+/**
+ * Starknet CCTP V2 `receive_message` Call builder.
+ *
+ * Cairo signature:
+ *
+ *   fn receive_message(message: ByteArray, attestation: ByteArray) -> bool
+ *
+ * Same two-byte-array shape as EVM's `receiveMessage`. The recipient
+ * (or any third party) signs this on the destination side after Iris
+ * attests the burn.
+ */
+
+type BuildStarknetReceiveIntentInput = {
+    destination: StarknetChain;
+    /** 0x-prefixed CCTP message bytes from Iris. */
+    message: `0x${string}`;
+    /** 0x-prefixed attestation bytes from Iris. */
+    attestation: `0x${string}`;
+};
+type StarknetReceiveIntent = {
+    destination: StarknetChain;
+    call: StarknetCall;
+};
+declare function buildStarknetReceiveIntent(input: BuildStarknetReceiveIntentInput): StarknetReceiveIntent;
+
+type StellarStrkeyType = "G" | "M" | "C";
+declare function isValidStellarStrkey(s: string): boolean;
+/** Throws if `s` is not a valid strkey. */
+declare function strkeyType(s: string): StellarStrkeyType;
+/** The raw 32-byte payload of a G, M or C strkey, as CCTP carries it. */
+declare function decodeStrkeyToBytes32(s: string): Uint8Array;
+/** Encode a 32-byte payload as a contract strkey (C…). */
+declare function encodeContractStrkey(bytes: Uint8Array): string;
+/**
+ * Convert a Stellar contract strkey (C…) to its 0x-prefixed bytes32
+ * hex form. Used when an EVM `depositForBurn` needs to encode a
+ * Stellar contract as `mintRecipient` / `destinationCaller`.
+ */
+declare function contractStrkeyToBytes32Hex(s: string): `0x${string}`;
+
+/**
+ * Convert from Stellar's 7-decimal subunit amount to CCTP's 6-decimal
+ * canonical amount. Drops the 7th decimal (rounds toward zero). The
+ * dust stays on Stellar; it's not lost in the bridge.
+ *
+ * @returns 6-decimal subunits (canonical amount for the CCTP message)
+ */
+declare function stellarSubunitsToCanonical(stellarSubunits: bigint): bigint;
+/**
+ * Convert from CCTP's 6-decimal canonical amount to Stellar's 7-decimal
+ * subunit amount. Scales by 10, as the inbound mint does.
+ *
+ * @returns 7-decimal subunits (the on-chain amount minted on Stellar)
+ */
+declare function canonicalToStellarSubunits(canonicalSubunits: bigint): bigint;
+/**
+ * The fractional 7th decimal that a burn from Stellar drops and leaves
+ * in the sender's account.
+ */
+declare function stellarBurnDust(stellarSubunits: bigint): bigint;
+
+/**
+ * @param forwardRecipientStrkey - Stellar strkey of the final recipient
+ *   (G…, C…, or M… address). The Forwarder will atomically transfer
+ *   minted USDC to this address after the on-chain mint.
+ * @param integratorPayload - Optional extra bytes appended after the
+ *   strkey. Whisk doesn't use it.
+ * @returns 0x-prefixed hex string ready for the EVM/Solana burn call.
+ */
+declare function buildStellarForwarderHookData(forwardRecipientStrkey: string, integratorPayload?: Uint8Array): `0x${string}`;
+
+/**
+ * Stellar CCTP V2 `deposit_for_burn` invocation builder.
+ *
+ * Soroban contract entry points (from `circlefin/stellar-cctp`):
+ *
+ *   deposit_for_burn(
+ *     caller: Address,
+ *     amount: i128,                    // 7-decimal subunits (local USDC)
+ *     destination_domain: u32,
+ *     mint_recipient: BytesN<32>,
+ *     burn_token: Address,             // USDC SAC contract
+ *     destination_caller: BytesN<32>,
+ *     max_fee: i128,                   // 7-decimal subunits
+ *     min_finality_threshold: u32,
+ *   )
+ *
+ *   deposit_for_burn_with_hook(
+ *     ...same as above plus...
+ *     hook_data: Bytes,
+ *   )
+ *
+ * The contract internally normalizes 7-decimal local amounts to
+ * 6-decimal canonical for the message. Dust below 0.0000001 USDC stays
+ * on the user's Stellar balance.
+ *
+ * `amount` and `max_fee` here are expressed in Stellar's 7-decimal
+ * subunits: multiply 6-decimal CCTP amounts by 10 before passing in.
+ */
+
+type StellarInvocation = {
+    ecosystem: "stellar";
+    contractId: string;
+    functionName: string;
+    args: xdr.ScVal[];
+    /** Pre-built XDR operation the adapter wraps in a Soroban transaction. */
+    operation: xdr.Operation;
+};
+type BuildStellarBurnIntentInput = {
+    source: StellarChain;
+    destinationDomain: number;
+    /**
+     * `mintRecipient` 32-byte payload as encoded into the CCTP message.
+     * The caller is responsible for encoding it correctly:
+     *   - EVM       20-byte address left-padded to 32 bytes
+     *   - Solana    recipient USDC ATA pubkey (32 bytes raw)
+     *   - Starknet  felt zero-padded to 32 bytes
+     */
+    mintRecipientBytes32: Uint8Array;
+    /** Amount in 7-decimal Stellar USDC subunits. */
+    amount: bigint;
+    /** Max fee in 7-decimal Stellar USDC subunits. */
+    maxFee: bigint;
+    /**
+     * `destinationCaller` 32-byte payload. For Stellar destinations this
+     * MUST equal the `CctpForwarder` decoded to bytes32; for other
+     * destinations this is typically 32 zero bytes (any caller).
+     */
+    destinationCallerBytes32: Uint8Array;
+    /** Caller strkey (G or C). The wallet that authorizes the burn. */
+    caller: string;
+    /**
+     * Optional hookData. When set, the builder targets
+     * `deposit_for_burn_with_hook`; when unset, it targets the plain
+     * `deposit_for_burn`.
+     */
+    hookData?: Uint8Array;
+    /** 2000 on Stellar, which has no Fast Transfer. Take it from the fee tier. */
+    minFinalityThreshold: FinalityThreshold;
+};
+type StellarBurnIntent = {
+    source: StellarChain;
+    destinationDomain: number;
+    amount: bigint;
+    maxFee: bigint;
+    invocation: StellarInvocation;
+    withHook: boolean;
+};
+declare function buildStellarBurnIntent(input: BuildStellarBurnIntentInput): StellarBurnIntent;
+/** The 32-byte payload of a strkey, as CCTP message fields carry it. */
+declare function strkeyTo32Bytes(strkey: string): Uint8Array;
+
+type BuildStellarApproveInvocationInput = {
+    source: StellarChain;
+    /** Owner strkey (G/M/C): the wallet authorizing TMM to spend USDC. */
+    owner: string;
+    /** Usually the chain's TMM contract (C...). */
+    spender: string;
+    /** Amount in 7-decimal Stellar USDC subunits. */
+    amount: bigint;
+    /**
+     * Ledger sequence at which the allowance expires. The SAC rejects a
+     * nonzero allowance that expires before the current ledger, so pass the
+     * latest ledger plus a short window.
+     */
+    expirationLedger: number;
+};
+declare function buildStellarApproveInvocation(input: BuildStellarApproveInvocationInput): StellarInvocation;
+
+type BuildStellarMintIntentInput = {
+    destination: StellarChain;
+    /** Raw CCTP message bytes from Iris. */
+    message: Uint8Array;
+    /** Raw attestation bytes from Iris. */
+    attestation: Uint8Array;
+};
+type StellarMintIntent = {
+    destination: StellarChain;
+    invocation: StellarInvocation;
+};
+declare function buildStellarMintIntent(input: BuildStellarMintIntentInput): StellarMintIntent;
+
+/**
+ * Program-Derived Address (PDA) helpers for CCTP V2 on Solana.
+ *
+ * Seed conventions verified against Circle's
+ * `circlefin/solana-cctp-contracts` (programs/v2). Two key gotchas:
+ *
+ *   - `remote_token_messenger` uses the destination domain encoded as
+ *     its *decimal string* bytes, NOT u32 LE. So domain 0 →
+ *     `Buffer.from("0", "utf8")`, not `Buffer.from([0, 0, 0, 0])`.
+ *   - `token_pair` uses the source domain as decimal string too,
+ *     plus the 32-byte source-token pubkey (left-padded EVM address
+ *     for non-Solana sources).
+ */
+
+/** Seed prefix bytes for each PDA we need. */
+declare const SEEDS: {
+    readonly tokenMessenger: Uint8Array<ArrayBuffer>;
+    readonly tokenMinter: Uint8Array<ArrayBuffer>;
+    readonly senderAuthority: Uint8Array<ArrayBuffer>;
+    readonly remoteTokenMessenger: Uint8Array<ArrayBuffer>;
+    readonly localToken: Uint8Array<ArrayBuffer>;
+    readonly tokenPair: Uint8Array<ArrayBuffer>;
+    readonly custody: Uint8Array<ArrayBuffer>;
+    readonly denylistAccount: Uint8Array<ArrayBuffer>;
+    readonly messageTransmitter: Uint8Array<ArrayBuffer>;
+    readonly messageTransmitterAuthority: Uint8Array<ArrayBuffer>;
+    readonly usedNonce: Uint8Array<ArrayBuffer>;
+    readonly eventAuthority: Uint8Array<ArrayBuffer>;
+};
+/** `token_messenger` PDA on the TokenMessengerMinter program. */
+declare function deriveTokenMessenger(tokenMessengerMinterProgram: PublicKey): PublicKey;
+/** `token_minter` PDA on the TokenMessengerMinter program. */
+declare function deriveTokenMinter(tokenMessengerMinterProgram: PublicKey): PublicKey;
+/** `sender_authority` PDA on the TokenMessengerMinter program. */
+declare function deriveSenderAuthority(tokenMessengerMinterProgram: PublicKey): PublicKey;
+/**
+ * `remote_token_messenger` PDA, keyed by the **destination domain**
+ * as its decimal string representation (Circle's convention).
+ */
+declare function deriveRemoteTokenMessenger(tokenMessengerMinterProgram: PublicKey, domain: number): PublicKey;
+/** `local_token` PDA, keyed by the local USDC SPL mint. */
+declare function deriveLocalToken(tokenMessengerMinterProgram: PublicKey, mint: PublicKey): PublicKey;
+/**
+ * `token_pair` PDA, used on the receive (mint) side to map a
+ * (source domain, source token) pair to the local mint. Source token
+ * is 32 bytes (left-padded for EVM sources).
+ */
+declare function deriveTokenPair(tokenMessengerMinterProgram: PublicKey, sourceDomain: number, sourceTokenBytes32: Uint8Array): PublicKey;
+/** `custody` token account PDA, keyed by the local USDC mint. */
+declare function deriveCustodyTokenAccount(tokenMessengerMinterProgram: PublicKey, mint: PublicKey): PublicKey;
+/**
+ * `denylist_account` PDA, owner-keyed. Burn fails if this PDA exists
+ * with data; the user's denylist record is "absence of data."
+ */
+declare function deriveDenylistAccount(tokenMessengerMinterProgram: PublicKey, owner: PublicKey): PublicKey;
+/** `message_transmitter` config PDA on the MessageTransmitter program. */
+declare function deriveMessageTransmitter(messageTransmitterProgram: PublicKey): PublicKey;
+/**
+ * `message_transmitter_authority` PDA, keyed by the *receiver*
+ * program. For CCTP burns, the receiver is the TokenMessengerMinter.
+ */
+declare function deriveMessageTransmitterAuthority(messageTransmitterProgram: PublicKey, receiverProgram: PublicKey): PublicKey;
+/**
+ * `used_nonce` PDA, seeded by the 32-byte nonce in the CCTP message
+ * header: `message[12..44]` per Circle's `Message::NONCE_INDEX` /
+ * `Message::SENDER_INDEX` layout.
+ */
+declare function deriveUsedNonce(messageTransmitterProgram: PublicKey, messageBytes: Uint8Array): PublicKey;
+/** `__event_authority` PDA, used by Anchor's `#[event_cpi]`. */
+declare function deriveEventAuthority(programId: PublicKey): PublicKey;
+
+/**
+ * Snake-case the name as the Rust function declares it
+ * (`deposit_for_burn`, not `depositForBurn`).
+ *
+ * Uses `@noble/hashes` because this runs at module load in browser
+ * bundles, where `node:crypto` isn't available.
+ */
+declare function anchorDiscriminator(snakeCaseName: string): Uint8Array;
+/** TokenMessengerMinterV2 `deposit_for_burn` (no hook data). */
+declare const DISCRIMINATOR_DEPOSIT_FOR_BURN: Uint8Array;
+/** TokenMessengerMinterV2 `deposit_for_burn_with_hook`. */
+declare const DISCRIMINATOR_DEPOSIT_FOR_BURN_WITH_HOOK: Uint8Array;
+/** MessageTransmitterV2 `receive_message`. */
+declare const DISCRIMINATOR_RECEIVE_MESSAGE: Uint8Array;
+
+/**
+ * Solana CCTP V2 `deposit_for_burn` / `deposit_for_burn_with_hook`
+ * instruction builder.
+ *
+ * Account list verified against
+ * `circlefin/solana-cctp-contracts/programs/v2/token-messenger-minter-v2`:
+ *
+ *   1.  owner                        (signer, ro)
+ *   2.  event_rent_payer             (signer, writable)
+ *   3.  sender_authority_pda         (ro)        PDA["sender_authority"] on TMM
+ *   4.  burn_token_account           (writable)  user's USDC ATA
+ *   5.  denylist_account             (ro)        PDA["denylist_account", owner] on TMM
+ *   6.  message_transmitter          (writable)  PDA["message_transmitter"] on MT
+ *   7.  token_messenger              (ro)        PDA["token_messenger"] on TMM
+ *   8.  remote_token_messenger       (ro)        PDA["remote_token_messenger", destDomain.toString()] on TMM
+ *   9.  token_minter                 (ro)        PDA["token_minter"] on TMM
+ *  10.  local_token                  (writable)  PDA["local_token", burnTokenMint] on TMM
+ *  11.  burn_token_mint              (writable)
+ *  12.  message_sent_event_data      (signer, writable)  fresh keypair, generated client-side
+ *  13.  message_transmitter_program  (ro)
+ *  14.  token_messenger_minter_program (ro)
+ *  15.  token_program                (ro)
+ *  16.  system_program               (ro)
+ *  17.  event_authority              (ro)        PDA["__event_authority"] on TMM (added by #[event_cpi])
+ *  18.  program                      (ro)        TMM program ID (added by #[event_cpi])
+ *
+ * Encoding (Borsh):
+ *   amount:                u64 LE
+ *   destination_domain:    u32 LE
+ *   mint_recipient:        Pubkey (32 bytes)
+ *   destination_caller:    Pubkey (32 bytes)
+ *   max_fee:               u64 LE
+ *   min_finality_threshold: u32 LE
+ *   hook_data:             Vec<u8>   [only for deposit_for_burn_with_hook]
+ */
+
+declare const ANY_DESTINATION_CALLER: PublicKey;
+type BuildSolanaBurnIntentInput = {
+    source: SolanaChain;
+    /** Destination chain CCTP domain (0=Eth, 1=Avax, 3=Arb, 6=Base, etc.). */
+    destinationDomain: number;
+    /** USDC subunits (6 decimals). Must be > 0 and ≤ 10M USDC. */
+    amount: bigint;
+    /**
+     * Recipient on the destination chain, as 32 bytes (bytes32-encoded).
+     * EVM addresses are left-padded; Solana addresses pass through.
+     */
+    mintRecipientBytes32: Uint8Array;
+    /** USDC subunits; caps the protocol + forwarder fees. */
+    maxFee: bigint;
+    owner: PublicKey;
+    /** Fresh keypair pubkey for `message_sent_event_data`. */
+    messageSentEventDataKey: PublicKey;
+    /** User's USDC ATA on the source chain. */
+    ownerUsdcAta: PublicKey;
+    /** `destinationCaller` as bytes32. Defaults to any caller. */
+    destinationCallerBytes32?: Uint8Array;
+    /**
+     * Non-empty bytes (the `cctp-forward` hookData, or the Stellar
+     * Forwarder's) select `deposit_for_burn_with_hook`. Leave unset for
+     * the plain burn.
+     */
+    hookData?: Uint8Array;
+    /** Take it from the fee tier. */
+    minFinalityThreshold: FinalityThreshold;
+};
+type SolanaInstruction = {
+    programId: PublicKey;
+    keys: AccountMeta[];
+    data: Buffer;
+    ecosystem: "solana";
+};
+type SolanaBurnIntent = {
+    source: SolanaChain;
+    destinationDomain: number;
+    amount: bigint;
+    maxFee: bigint;
+    instruction: SolanaInstruction;
+    /** Pubkey the caller must include as a fresh signer. */
+    messageSentEventDataKey: PublicKey;
+    withHook: boolean;
+};
+declare function buildSolanaBurnIntent(input: BuildSolanaBurnIntentInput): SolanaBurnIntent;
+/**
+ * Convenience: build a `TransactionInstruction` directly from the
+ * intent. Most callers will want this; the raw `instruction` shape
+ * keeps the type stable across `@solana/web3.js` minor versions.
+ */
+declare function burnIntentToTransactionInstruction(intent: SolanaBurnIntent): TransactionInstruction;
+
+/**
+ * Solana CCTP V2 `receive_message` instruction builder.
+ *
+ * `receive_message` is dispatched on `MessageTransmitterV2`. It does
+ * its own attestation verification, opens a `used_nonce` PDA, then
+ * CPIs into the receiver program (TokenMessengerMinterV2) via
+ * `handle_receive_finalized_message`. All accounts the receiver needs
+ * are appended after MessageTransmitter's own.
+ *
+ * Account list verified against
+ * `circlefin/solana-cctp-contracts/programs/v2`:
+ *
+ * MessageTransmitterV2 ReceiveMessageContext (with #[event_cpi]):
+ *   1.  payer                           (signer, writable)
+ *   2.  caller                          (signer, ro)
+ *   3.  authority_pda                   (ro)
+ *   4.  message_transmitter             (ro)
+ *   5.  used_nonce                      (writable, init)
+ *   6.  receiver                        (ro)  TMM program
+ *   7.  system_program                  (ro)
+ *   8.  event_authority (MT)            (ro)
+ *   9.  program (MT)                    (ro)
+ *
+ * Remaining accounts, from TokenMessengerMinterV2's
+ * HandleReceiveMessageContext (with #[event_cpi]):
+ *  10.  token_messenger                 (ro)
+ *  11.  remote_token_messenger          (ro)
+ *  12.  token_minter                    (writable)
+ *  13.  local_token                     (writable)
+ *  14.  token_pair                      (ro)
+ *  15.  fee_recipient_token_account     (writable)
+ *  16.  recipient_token_account         (writable)
+ *  17.  custody_token_account           (writable)
+ *  18.  token_program                   (ro)
+ *  19.  event_authority (TMM)           (ro)
+ *  20.  program (TMM)                   (ro)
+ */
+
+type BuildSolanaReceiveIntentInput = {
+    destination: SolanaChain;
+    /** Raw CCTP message bytes from Iris. */
+    message: Uint8Array;
+    /** Raw attestation bytes from Iris. */
+    attestation: Uint8Array;
+    /** Source CCTP domain (the chain the burn came from). */
+    sourceDomain: number;
+    /** Source-chain USDC token, 32-byte left-padded. */
+    sourceTokenBytes32: Uint8Array;
+    /** The `fee_recipient` ATA, read from the on-chain TokenMessenger state. */
+    feeRecipientUsdcAta: PublicKey;
+    /** End-recipient's USDC ATA on Solana. Must be pre-created. */
+    recipientUsdcAta: PublicKey;
+    /** Pays for and signs the receive. Also passed as `caller`. */
+    payer: PublicKey;
+};
+type SolanaReceiveIntent = {
+    destination: SolanaChain;
+    instruction: {
+        programId: PublicKey;
+        keys: AccountMeta[];
+        data: Buffer;
+        ecosystem: "solana";
+    };
+};
+declare function buildSolanaReceiveIntent(input: BuildSolanaReceiveIntentInput): SolanaReceiveIntent;
+/** Convenience: produce a `TransactionInstruction` from the intent. */
+declare function receiveIntentToTransactionInstruction(intent: SolanaReceiveIntent): TransactionInstruction;
+
+/**
+ * Solana CCTP on-chain state parsing.
+ *
+ * The TokenMessenger account holds the `fee_recipient` pubkey that
+ * `receive_message` requires as a remaining-account constraint. The
+ * account isn't derived: it's an arbitrary owner-configured pubkey
+ * stored in state, so the executor must read it from chain.
+ *
+ * Account layout (Anchor, verified against Circle's
+ * `programs/v2/token-messenger-minter/src/token_messenger/state.rs`):
+ *
+ *   0..8     discriminator
+ *   8..40    denylister              Pubkey
+ *   40..72   owner                   Pubkey
+ *   72..104  pending_owner           Pubkey
+ *   104..108 message_body_version    u32 LE
+ *   108..109 authority_bump          u8
+ *   109..141 fee_recipient           Pubkey
+ *   141..173 min_fee_controller      Pubkey
+ *   173..177 min_fee                 u32 LE
+ */
+
+/** Throws if the account data ends before `fee_recipient` does. */
+declare function parseTokenMessengerFeeRecipient(accountData: Uint8Array): PublicKey;
+
+/**
+ * CCTP V2 protocol layer.
+ *
+ * Owns the direct integration with CCTP V2 contracts and Circle's Iris
+ * attestation API. Pure protocol builders and HTTP client; no wallet
+ * state, no transaction submission.
+ */
+declare const VERSION = "0.1.0";
+
+export { ANY_DESTINATION_CALLER$1 as ANY_DESTINATION_CALLER, Address, type BuildBurnIntentInput, type BuildBurnWithFeesIntentInput, type BuildMintIntentInput, type BuildSolanaBurnIntentInput, type BuildSolanaReceiveIntentInput, type BuildStarknetBurnIntentInput, type BuildStarknetReceiveIntentInput, type BuildStellarBurnIntentInput, type BuildStellarMintIntentInput, BurnFeeTier, type BurnIntent, type BurnWithFeesIntent, CCTP_FORWARD_HOOK_DATA, CCTP_FORWARD_HOOK_DATA_LENGTH, CctpChain, type ComputeMaxFeeInput, type ComputeMaxFeeResult, DISCRIMINATOR_DEPOSIT_FOR_BURN, DISCRIMINATOR_DEPOSIT_FOR_BURN_WITH_HOOK, DISCRIMINATOR_RECEIVE_MESSAGE, type DecodedBurnMessage, type EvmCall, EvmChain, FinalityThreshold, ForwarderFeeTier, type GetStandardMinFeeOptions, InvalidAddressError, InvalidBytes32Error, InvalidInputError, type MintIntent, type RpcOptions, ANY_DESTINATION_CALLER as SOLANA_ANY_DESTINATION_CALLER, SEEDS as SOLANA_CCTP_PDA_SEEDS, type SolanaBurnIntent, SolanaChain, type SolanaInstruction, type SolanaReceiveIntent, type StarknetBurnIntent, type StarknetCall, StarknetChain, StarknetFelt, type StarknetReceiveIntent, type StarknetTransactionStatus, type StellarBurnIntent, StellarChain, type StellarInvocation, type StellarMintIntent, type StellarStrkeyType, type TransactionStatus, VERSION, anchorDiscriminator, assertStarknetFelt, buildBurnIntent, buildBurnWithFeesIntent, buildForwarderHookData, buildMintIntent, buildSolanaBurnIntent, buildSolanaReceiveIntent, buildStarknetApproveCall, buildStarknetBurnIntent, buildStarknetReceiveIntent, buildStellarApproveInvocation, buildStellarBurnIntent, buildStellarForwarderHookData, buildStellarMintIntent, burnIntentToTransactionInstruction, bytes32HexToFelt, bytesToByteArrayFelts, canonicalToStellarSubunits, computeBurnFee, computeMaxFee, contractStrkeyToBytes32Hex, decodeBurnMessage, decodeStrkeyToBytes32, deriveCustodyTokenAccount, deriveDenylistAccount, deriveEventAuthority, deriveLocalToken, deriveMessageTransmitter, deriveMessageTransmitterAuthority, deriveRemoteTokenMessenger, deriveSenderAuthority, deriveTokenMessenger, deriveTokenMinter, deriveTokenPair, deriveUsedNonce, encodeContractStrkey, feltToBigInt, feltToBytes32Hex, fromBytes32, getBlockNumber, getGasPrice, getStandardMinFee, getStarknetTransactionStatus, getTransactionStatus, getUsdcBalance, hexToByteArrayFelts, isAddress, isForwarderHookData, isNonceUsed, isStarknetNonceUsed, isStellarNonceUsed, isValidStarknetFelt, isValidStellarStrkey, parseFeeBps, parseForwarderFee, parseTokenMessengerFeeRecipient, receiveIntentToTransactionInstruction, selectForwarderFee, feltToString as starknetFeltToString, stellarBurnDust, stellarSubunitsToCanonical, strkeyTo32Bytes, strkeyType, toBytes32, tryFromBytes32, u256ToFelts };