damm-sdk 1.4.18 → 1.4.21

package/dist/integrations/wormhole/wormhole.multi.ntt.d.ts

@@ -0,0 +1,149 @@
+import type { Address } from "viem";
+import type { Call, HexString, Unwrapable } from "../../types";
+/**
+ * Wormhole uint16 chain IDs.
+ *
+ * Wormhole uses its own chain-ID space distinct from EVM chain IDs.
+ * Reference: https://wormhole.com/docs/products/reference/chain-ids/
+ */
+export declare const WORMHOLE_CHAIN_IDS: Readonly<Record<number, number>>;
+/**
+ * Resolve the Wormhole chain ID for an EVM chain ID.
+ * @throws if the chain has no Wormhole chain ID registered.
+ */
+export declare const getWormholeChainId: (chainId: number) => number;
+/**
+ * Left-pad a 20-byte address to bytes32 (the standard ABI encoding used
+ * by Wormhole NTT for `recipient` / `refundAddress` fields).
+ */
+export declare const addressToBytes32: (addr: Address) => HexString;
+export type ExecutorArgs = Readonly<{
+    /** Relay fee paid to the executor (forwarded as msg.value). */
+    value: bigint;
+    /** Where the executor refunds unused gas on the SOURCE chain. */
+    refundAddress: Address;
+    /** Signed quote bytes from the executor API. */
+    signedQuote: HexString;
+    /** Relay instructions bytes (see buildRelayInstructions). */
+    instructions: HexString;
+}>;
+export type FeeArgs = Readonly<{
+    /** App-level fee in deci-basis points (10_000 = 100%). Always 0 for DAMM. */
+    dbps: number;
+    /** Fee recipient. Irrelevant when dbps = 0. */
+    payee: Address;
+}>;
+export type WormholeTransferArgs = Readonly<{
+    /** MultiTokenNTT manager address on the source chain. */
+    multiTokenNtt: Address;
+    /** ERC20 token to bridge (e.g. WETH). */
+    token: Address;
+    /** Amount to bridge (token smallest unit). */
+    amount: bigint;
+    /** Destination chain (Wormhole chain ID, not EVM). */
+    recipientChain: number;
+    /** Destination address (bytes32, left-padded). Use addressToBytes32(). */
+    recipient: HexString;
+    /** Top-level refund address on the DESTINATION chain (bytes32). */
+    refundAddress: HexString;
+    /** Transceiver instructions. Pass "0x" for defaults. */
+    transceiverInstructions: HexString;
+    executorArgs: ExecutorArgs;
+    feeArgs: FeeArgs;
+}>;
+/**
+ * Encode calldata for `MultiNTTWithExecutor.transfer(...)`.
+ */
+export declare const WormholeTransferCalldata: (args: WormholeTransferArgs) => HexString;
+/**
+ * Build a Call for `MultiNTTWithExecutor.transfer(...)`.
+ *
+ * `msg.value` = `executorArgs.value` (Executor relay fee) + any per-transceiver
+ * delivery fees required by the underlying `MultiTokenNTT` (e.g. Axelar's
+ * gateway fee on the Monad ↔ Ethereum lane).
+ *
+ * Pass `transceiverFee` when the `MultiTokenNTT` uses a paid transceiver in
+ * addition to Wormhole's guardian signing. Query the exact amount via
+ * `GmpManager.quoteDeliveryPrice(recipientChain, transceiverInstructions)`
+ * (see `GmpManagerQuoteDeliveryPriceCalldata`).
+ */
+export declare const wormholeTransferTrx: ({ wrapperAddress, args, transceiverFee, }: {
+    /** MultiNTTWithExecutor address on the source chain. */
+    wrapperAddress: Address;
+    args: WormholeTransferArgs;
+    /** Extra native token required by paid transceivers (e.g. Axelar). */
+    transceiverFee?: bigint | undefined;
+}) => Unwrapable<Call>;
+/**
+ * Default `gasLimit` for `MultiTokenNTT` redemption on the destination chain.
+ *
+ * MultiNTT redemption is expensive because it:
+ *   (a) verifies the Wormhole VAA (guardian signatures + replay protection)
+ *   (b) verifies the sibling transceiver's attestation (2/2 check)
+ *   (c) executes the token mint/transfer on the destination `MultiTokenNTT`
+ *
+ * Empirically, successful Monad ↔ Mainnet transfers use ~650_000 gas; manual
+ * `receiveMessage` calls land in ~330_000. Default is 1_000_000 to leave
+ * headroom for future protocol upgrades and any per-block variance — the
+ * extra cost is tiny (~$0.20 per Monad→Mainnet bridge at typical prices)
+ * and eliminates `evm_simulation_gas_too_low` rejections from the Executor.
+ *
+ * Note: this is gas UNITS, not gas PRICE. It does not need to track network
+ * congestion — destination-chain gas usage is deterministic. What network
+ * spikes affect is the COST of providing this budget; that's bounded
+ * separately by the `etherWithinAllowance` permission cap in the kit.
+ *
+ * Override per-call via `buildRelayInstructions({ gasLimit: N })` if you have
+ * empirical data showing a different value is appropriate for your asset/lane.
+ */
+export declare const DEFAULT_NTT_REDEMPTION_GAS_LIMIT = 1000000n;
+/**
+ * Encode `GasInstruction` relay instructions for the executor.
+ *
+ * Format (per Wormhole SDK): `0x01` (version) || uint128 gasLimit || uint128 msgValue
+ * - `gasLimit`: gas units the executor should provide when redeeming on the destination
+ * - `msgValue`: native token (in wei on destination) to forward with the redemption call
+ *
+ * Default `gasLimit` is `DEFAULT_NTT_REDEMPTION_GAS_LIMIT` (650k), calibrated
+ * for `MultiTokenNTT` with a 2/2 transceiver stack. Override only if you know
+ * the destination chain's redemption consumes less.
+ */
+export declare const buildRelayInstructions: ({ gasLimit, msgValue, }?: {
+    gasLimit?: bigint | undefined;
+    msgValue?: bigint | undefined;
+}) => HexString;
+/**
+ * Encode calldata for the view function `calculateFee(amount, dbps)`.
+ * Useful to query the dbps-based fee charged by the wrapper off-chain.
+ */
+export declare const WormholeCalculateFeeCalldata: ({ amount, dbps }: {
+    amount: bigint;
+    dbps: number;
+}) => HexString;
+/**
+ * Compose a `WormholeTransferArgs` where recipient and refund addresses
+ * default to the same avatar (the Safe on both chains share an address).
+ *
+ * This matches the permission constraint in Our-DeFi-Kit's
+ * `WormholeBridgingPermissions`, which scopes `recipient`, top-level
+ * `refundAddress`, and `executorArgs.refundAddress` all to `c.avatar`.
+ */
+export declare const buildWormholeTransferArgsFromAvatar: ({ multiTokenNtt, token, amount, recipientChain, avatar, relayFee, signedQuote, relayInstructions, transceiverInstructions, dbps, payee, }: {
+    multiTokenNtt: Address;
+    token: Address;
+    amount: bigint;
+    /** Wormhole chain ID (not EVM). */
+    recipientChain: number;
+    /** The Safe address (same on source + destination). */
+    avatar: Address;
+    /** Native relay fee to forward (from signed quote estimatedCost). */
+    relayFee: bigint;
+    signedQuote: HexString;
+    relayInstructions: HexString;
+    transceiverInstructions?: `0x${string}` | undefined;
+    /** Defaults to 0 — DAMM never charges a skim fee. */
+    dbps?: number | undefined;
+    /** Defaults to the zero address when dbps = 0 (irrelevant). */
+    payee?: `0x${string}` | undefined;
+}) => WormholeTransferArgs;
+//# sourceMappingURL=wormhole.multi.ntt.d.ts.map

package/dist/integrations/wormhole/wormhole.multi.ntt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wormhole.multi.ntt.d.ts","sourceRoot":"","sources":["../../../src/integrations/wormhole/wormhole.multi.ntt.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK/D;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAG9D,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB,YAAa,MAAM,KAAG,MAMpD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,SAAU,OAAO,KAAG,SAA+D,CAAC;AAIjH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAChC,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,aAAa,EAAE,OAAO,CAAC;IACvB,gDAAgD;IAChD,WAAW,EAAE,SAAS,CAAC;IACvB,6DAA6D;IAC7D,YAAY,EAAE,SAAS,CAAC;CAC3B,CAAC,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC;IAC3B,6EAA6E;IAC7E,IAAI,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,KAAK,EAAE,OAAO,CAAC;CAClB,CAAC,CAAC;AAIH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IACxC,yDAAyD;IACzD,aAAa,EAAE,OAAO,CAAC;IACvB,yCAAyC;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,cAAc,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,SAAS,EAAE,SAAS,CAAC;IACrB,mEAAmE;IACnE,aAAa,EAAE,SAAS,CAAC;IACzB,wDAAwD;IACxD,uBAAuB,EAAE,SAAS,CAAC;IACnC,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC;CACpB,CAAC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB,SAAU,oBAAoB,KAAG,SAoBrE,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB;IAK5B,wDAAwD;oBACxC,OAAO;UACjB,oBAAoB;IAC1B,sEAAsE;;MAEtE,WAAW,IAAI,CAOlB,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gCAAgC,WAAa,CAAC;AAE3D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB;;;MAM1B,SAQR,CAAC;AAIF;;;GAGG;AACH,eAAO,MAAM,4BAA4B;YAAgC,MAAM;UAAQ,MAAM;MAAK,SAEjG,CAAC;AAIF;;;;;;;GAOG;AACH,eAAO,MAAM,mCAAmC;mBAa7B,OAAO;WACf,OAAO;YACN,MAAM;IACd,mCAAmC;oBACnB,MAAM;IACtB,uDAAuD;YAC/C,OAAO;IACf,qEAAqE;cAC3D,MAAM;iBACH,SAAS;uBACH,SAAS;;IAE5B,qDAAqD;;IAErD,+DAA+D;;MAE/D,oBAqBH,CAAC"}

package/dist/integrations/wormhole/wormhole.scan.api.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Client for the WormholeScan public API — used to fetch the signed VAA
+ * emitted by a source-chain transceiver for a given cross-chain message.
+ *
+ * Endpoints:
+ *   - Mainnet: https://api.wormholescan.io
+ *   - Testnet: https://api.testnet.wormholescan.io
+ *
+ * API reference: https://docs.wormhole.com/wormhole/reference/api-docs/wormholescan
+ */
+import type { HexString } from "../../types";
+export declare const WORMHOLESCAN_API_MAINNET: "https://api.wormholescan.io";
+export declare const WORMHOLESCAN_API_TESTNET: "https://api.testnet.wormholescan.io";
+export type WormholeNetworkEnv = "Mainnet" | "Testnet";
+export declare const getWormholeScanApiUrl: (network?: WormholeNetworkEnv) => string;
+/**
+ * Convert a 20-byte address to the 64-char (32-byte) padded lowercase hex
+ * format WormholeScan expects for the `emitter` URL segment.
+ */
+export declare const normalizeEmitterForVaaLookup: (emitter: HexString) => string;
+export type VaaLookupArgs = Readonly<{
+    /** Wormhole chain ID of the source chain (NOT EVM chainId). */
+    emitterChain: number;
+    /** Source-chain transceiver address — 20 or 32 byte hex. */
+    emitterAddress: HexString;
+    /** Sequence number emitted by the Wormhole core bridge. */
+    sequence: number | bigint;
+}>;
+export type VaaLookupResponse = Readonly<{
+    sequence: number;
+    id: string;
+    emitterChain: number;
+    emitterAddr: string;
+    emitterNativeAddr: string;
+    /** Base64-encoded signed VAA bytes. */
+    vaa: string;
+    timestamp?: string;
+    txHash?: string;
+    digest?: string;
+}>;
+/**
+ * Fetch the signed VAA for a given (chain, emitter, sequence).
+ *
+ * Throws if WormholeScan returns any non-2xx response (including 404, which
+ * happens during the brief window after the source tx confirms but before
+ * guardians have signed). Callers that want to poll should wrap this in a
+ * retry loop — letting the caller decide whether a 404 is a transient
+ * "not-yet-signed" or a permanent "wrong inputs" condition.
+ */
+export declare const fetchWormholeVAA: (args: VaaLookupArgs, network?: WormholeNetworkEnv) => Promise<VaaLookupResponse>;
+/**
+ * Decode a base64 VAA string into 0x-prefixed hex bytes, ready for
+ * `WormholeReceiveMessageCalldata`.
+ */
+export declare const decodeVaaBase64: (base64: string) => HexString;
+//# sourceMappingURL=wormhole.scan.api.d.ts.map

package/dist/integrations/wormhole/wormhole.scan.api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wormhole.scan.api.d.ts","sourceRoot":"","sources":["../../../src/integrations/wormhole/wormhole.scan.api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,eAAO,MAAM,wBAAwB,+BAAyC,CAAC;AAC/E,eAAO,MAAM,wBAAwB,uCAAiD,CAAC;AAEvF,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,SAAS,CAAC;AAEvD,eAAO,MAAM,qBAAqB,aAAa,kBAAkB,KAAe,MACD,CAAC;AAIhF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,YAAa,SAAS,KAAG,MAOjE,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACjC,+DAA+D;IAC/D,YAAY,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,cAAc,EAAE,SAAS,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;CAC7B,CAAC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,SACnB,aAAa,YACV,kBAAkB,KAC5B,QAAQ,iBAAiB,CAgB3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,WAAY,MAAM,KAAG,SACiC,CAAC"}

package/dist/integrations/wormhole/wormhole.transceiver.abi.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal ABI for Wormhole's `GenericWormholeTransceiver` — the destination-side
+ * contract that verifies a Wormhole VAA and forwards it as an attestation to
+ * the `GmpManager` so a pending cross-chain message can be executed.
+ *
+ * Mainnet: 0x9D0eADF3fc10380C4D2F5ba79499C6194549C7D2
+ * Monad:   0x1a0f31492Ca69DF6A82906Ce88613AeCD9245C44
+ *
+ * Only the one function we need for manual recovery: `receiveMessage`.
+ * The call is permissionless — any EOA with enough gas can deliver a VAA.
+ */
+declare const _default: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "encodedMessage";
+        readonly type: "bytes";
+    }];
+    readonly name: "receiveMessage";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+export default _default;
+//# sourceMappingURL=wormhole.transceiver.abi.d.ts.map

package/dist/integrations/wormhole/wormhole.transceiver.abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wormhole.transceiver.abi.d.ts","sourceRoot":"","sources":["../../../src/integrations/wormhole/wormhole.transceiver.abi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;;;;;;;;;;;AACH,wBAQW"}

package/dist/integrations/wormhole/wormhole.transceiver.d.ts

@@ -0,0 +1,28 @@
+import type { Address } from "viem";
+import type { Call, HexString, Unwrapable } from "../../types";
+/**
+ * Encode calldata for `GenericWormholeTransceiver.receiveMessage(bytes vaa)`.
+ *
+ * Use this to manually deliver a Wormhole VAA to the destination transceiver
+ * when auto-relay has failed (e.g. Executor pre-flight sim rejected the gas
+ * quote and aborted). The transceiver verifies the VAA's guardian signatures
+ * and forwards the attestation to the `GmpManager`; once the 2/2 threshold is
+ * met with the sibling transceiver (e.g. Axelar), `executeMsg` fires
+ * automatically in the same transaction.
+ */
+export declare const WormholeReceiveMessageCalldata: ({ vaa }: {
+    vaa: HexString;
+}) => HexString;
+/**
+ * Build a Call for manually delivering a VAA to the Wormhole transceiver.
+ *
+ * The call is permissionless (any EOA works), takes no value, and is safe to
+ * retry — the transceiver rejects duplicates.
+ */
+export declare const wormholeReceiveMessageTrx: ({ transceiverAddress, vaa, }: {
+    /** `GenericWormholeTransceiver` address on the destination chain. */
+    transceiverAddress: Address;
+    /** The signed VAA bytes, as fetched from WormholeScan. */
+    vaa: HexString;
+}) => Unwrapable<Call>;
+//# sourceMappingURL=wormhole.transceiver.d.ts.map

package/dist/integrations/wormhole/wormhole.transceiver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wormhole.transceiver.d.ts","sourceRoot":"","sources":["../../../src/integrations/wormhole/wormhole.transceiver.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAO/D;;;;;;;;;GASG;AACH,eAAO,MAAM,8BAA8B;SAAoB,SAAS;MAAK,SAE5E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;IAIlC,qEAAqE;wBACjD,OAAO;IAC3B,0DAA0D;SACrD,SAAS;MACd,WAAW,IAAI,CAOlB,CAAC"}

package/package.json

@@ -4,7 +4,7 @@
     "main": "./dist/index.cjs",
     "types": "./dist/index.d.ts",
     "type": "module",
-    "version": "1.4.18",
+    "version": "1.4.21",
     "files": [
         "dist",
         "src",
@@ -19,8 +19,9 @@
     },
     "scripts": {
         "build": "rm -rf ./dist && bun build ./src/index.ts --outdir ./dist --entry-naming index.js --format esm --sourcemap=external && bun build ./src/index.ts --outdir ./dist --entry-naming index.cjs --format cjs --sourcemap=external && bun tsc --project tsconfig.json",
+        "verify:dist": "bun run scripts/verify-dist.ts",
         "fmt": "prettier --write . && forge fmt",
-        "release": "bun run fmt && bun run build && npm publish --tag latest"
+        "release": "bun run fmt && bun run build && bun run verify:dist && npm publish --tag latest"
     },
     "devDependencies": {
         "@types/bun": "latest",

package/src/integrations/ccip/ccip.router.abi.ts

@@ -0,0 +1,62 @@
+/**
+ * Minimal ABI for Chainlink CCIP Router contract.
+ * Only includes functions needed for bridge operations.
+ *
+ * Full contract: https://etherscan.io/address/0x80226fc0Ee2b096224EeAc085Bb9a8cba1146f7D
+ */
+export default [
+    {
+        inputs: [
+            { name: "destinationChainSelector", type: "uint64" },
+            {
+                name: "message",
+                type: "tuple",
+                components: [
+                    { name: "receiver", type: "bytes" },
+                    { name: "data", type: "bytes" },
+                    {
+                        name: "tokenAmounts",
+                        type: "tuple[]",
+                        components: [
+                            { name: "token", type: "address" },
+                            { name: "amount", type: "uint256" },
+                        ],
+                    },
+                    { name: "feeToken", type: "address" },
+                    { name: "extraArgs", type: "bytes" },
+                ],
+            },
+        ],
+        name: "ccipSend",
+        outputs: [{ name: "messageId", type: "bytes32" }],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { name: "destinationChainSelector", type: "uint64" },
+            {
+                name: "message",
+                type: "tuple",
+                components: [
+                    { name: "receiver", type: "bytes" },
+                    { name: "data", type: "bytes" },
+                    {
+                        name: "tokenAmounts",
+                        type: "tuple[]",
+                        components: [
+                            { name: "token", type: "address" },
+                            { name: "amount", type: "uint256" },
+                        ],
+                    },
+                    { name: "feeToken", type: "address" },
+                    { name: "extraArgs", type: "bytes" },
+                ],
+            },
+        ],
+        name: "getFee",
+        outputs: [{ name: "fee", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+] as const;

package/src/integrations/ccip/ccip.router.ts

@@ -0,0 +1,172 @@
+import { ethers } from "ethers";
+import ccipRouterAbi from "./ccip.router.abi";
+import type { Call, HexString, Unwrapable } from "../../types";
+import { createCall } from "../../types";
+import type { Address } from "viem";
+
+const ccipRouterInterface = new ethers.utils.Interface(ccipRouterAbi as any);
+
+/**
+ * CCIP chain selectors (uint64).
+ * Source: https://docs.chain.link/ccip/directory/mainnet
+ * Verified on-chain 2026-04-13 via typeAndVersion() on each Router.
+ */
+export const CCIP_CHAIN_SELECTORS: Readonly<Record<number, string>> = Object.freeze({
+    1: "5009297550715157269", // Mainnet
+    42161: "4949039107694359620", // Arbitrum
+    8453: "15971525489660198786", // Base
+    10: "3734403246176062136", // Optimism
+    137: "4051577828743386545", // Polygon
+    56: "11344663589394136015", // BSC
+    143: "8481857512324358265", // Monad
+});
+
+/**
+ * Get the CCIP chain selector for a given chain ID.
+ * @throws if the chain is not supported
+ */
+export const getCCIPChainSelector = (chainId: number): string => {
+    const selector = CCIP_CHAIN_SELECTORS[chainId];
+    if (!selector) {
+        throw new Error(`CCIP: No chain selector for chainId ${chainId}`);
+    }
+    return selector;
+};
+
+// ─── EVM2AnyMessage struct ───────────────────────────────────────────────
+
+export type CCIPTokenAmount = Readonly<{
+    token: Address;
+    amount: bigint;
+}>;
+
+export type EVM2AnyMessage = Readonly<{
+    /** abi.encode(destinationAddress) */
+    receiver: HexString;
+    /** Empty (0x) for token-only transfers */
+    data: HexString;
+    /** Tokens to bridge */
+    tokenAmounts: readonly CCIPTokenAmount[];
+    /** address(0) = pay fee in native ETH/MON */
+    feeToken: Address;
+    /** Extra args (0x for defaults) */
+    extraArgs: HexString;
+}>;
+
+// ─── getFee ──────────────────────────────────────────────────────────────
+
+export type GetFeeArgs = Readonly<{
+    destinationChainSelector: string;
+    message: EVM2AnyMessage;
+}>;
+
+/**
+ * Encode calldata for Router.getFee(destinationChainSelector, message).
+ * Use this to quote the CCIP fee via an RPC call.
+ */
+export const CCIPGetFeeCalldata = (args: GetFeeArgs): HexString => {
+    return ccipRouterInterface.encodeFunctionData("getFee", [
+        args.destinationChainSelector,
+        {
+            receiver: args.message.receiver,
+            data: args.message.data,
+            tokenAmounts: args.message.tokenAmounts.map((t) => ({
+                token: t.token,
+                amount: t.amount,
+            })),
+            feeToken: args.message.feeToken,
+            extraArgs: args.message.extraArgs,
+        },
+    ]) as HexString;
+};
+
+/**
+ * Build a Call for Router.getFee (read-only, value=0).
+ */
+export const CCIPGetFeeTrx = ({
+    routerAddress,
+    args,
+}: {
+    routerAddress: Address;
+    args: GetFeeArgs;
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: routerAddress,
+        data: CCIPGetFeeCalldata(args),
+        value: 0n,
+    });
+};
+
+// ─── ccipSend ────────────────────────────────────────────────────────────
+
+export type CCIPSendArgs = Readonly<{
+    destinationChainSelector: string;
+    message: EVM2AnyMessage;
+    /** Native fee (from getFee). The Router does NOT refund excess. */
+    nativeFee: bigint;
+}>;
+
+/**
+ * Encode calldata for Router.ccipSend(destinationChainSelector, message).
+ */
+export const CCIPSendCalldata = (args: CCIPSendArgs): HexString => {
+    return ccipRouterInterface.encodeFunctionData("ccipSend", [
+        args.destinationChainSelector,
+        {
+            receiver: args.message.receiver,
+            data: args.message.data,
+            tokenAmounts: args.message.tokenAmounts.map((t) => ({
+                token: t.token,
+                amount: t.amount,
+            })),
+            feeToken: args.message.feeToken,
+            extraArgs: args.message.extraArgs,
+        },
+    ]) as HexString;
+};
+
+/**
+ * Build a Call for Router.ccipSend with msg.value = nativeFee.
+ */
+export const ccipSendTrx = ({
+    routerAddress,
+    args,
+}: {
+    routerAddress: Address;
+    args: CCIPSendArgs;
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: routerAddress,
+        data: CCIPSendCalldata(args),
+        value: args.nativeFee,
+    });
+};
+
+// ─── Helper: build EVM2AnyMessage for a single token bridge ──────────────
+
+/**
+ * Build a standard EVM2AnyMessage for bridging a single token.
+ * Receiver = abi.encode(destinationAddress), feeToken = address(0) (native).
+ */
+export const buildCCIPMessage = ({
+    receiver,
+    token,
+    amount,
+}: {
+    receiver: Address;
+    token: Address;
+    amount: bigint;
+}): EVM2AnyMessage => {
+    // Pad receiver to 32 bytes (abi.encode(address))
+    const receiverEncoded = ("0x" + receiver.slice(2).padStart(64, "0")) as HexString;
+
+    return Object.freeze({
+        receiver: receiverEncoded,
+        data: "0x" as HexString,
+        tokenAmounts: Object.freeze([Object.freeze({ token, amount })]),
+        feeToken: "0x0000000000000000000000000000000000000000" as Address,
+        extraArgs: "0x" as HexString,
+    });
+};

package/src/integrations/ccip/index.ts

@@ -0,0 +1,19 @@
+export { default as CCIPRouterAbi } from "./ccip.router.abi";
+export {
+    // Chain selectors
+    CCIP_CHAIN_SELECTORS,
+    getCCIPChainSelector,
+    // getFee
+    CCIPGetFeeCalldata,
+    CCIPGetFeeTrx,
+    // ccipSend
+    CCIPSendCalldata,
+    ccipSendTrx,
+    // Helper
+    buildCCIPMessage,
+    // Types
+    type CCIPTokenAmount,
+    type EVM2AnyMessage,
+    type GetFeeArgs,
+    type CCIPSendArgs,
+} from "./ccip.router";

package/src/integrations/index.ts

@@ -13,6 +13,7 @@ export * from "./slipstream";
 export * from "./morphoVault";
 export * from "./merkl";
 export * from "./oft";
+export * from "./ccip";
 export * from "./cctp";
 export * from "./erc721";
 export * from "./iporFusion";
@@ -22,3 +23,4 @@ export * from "./gearbox";
 export * from "./fluidLite";
 export * from "./weth";
 export * from "./pendle";
+export * from "./wormhole";

package/src/integrations/wormhole/axelar.gmp.api.ts

@@ -0,0 +1,85 @@
+/**
+ * Client for the Axelar GMP status API — used to track the Axelar side of
+ * Monad's 2/2 transceiver stack (Wormhole + Axelar).
+ *
+ * Axelar's relay network is independent of Wormhole's Executor: if the
+ * Executor aborts (e.g. gas-quote rejection), Axelar may still deliver on
+ * its own. Checking Axelar status helps decide how to recover.
+ *
+ * API reference: https://docs.axelarscan.io/gmp
+ */
+
+import type { HexString } from "../../types";
+
+export const AXELAR_GMP_API_MAINNET = "https://api.axelarscan.io" as const;
+export const AXELAR_GMP_API_TESTNET = "https://testnet.api.axelarscan.io" as const;
+
+export type AxelarNetwork = "Mainnet" | "Testnet";
+
+export const getAxelarGmpApiUrl = (network: AxelarNetwork = "Mainnet"): string =>
+    network === "Mainnet" ? AXELAR_GMP_API_MAINNET : AXELAR_GMP_API_TESTNET;
+
+// ─── POST /gmp/searchGMP ─────────────────────────────────────────────────
+
+/**
+ * Simplified status returned by Axelar's GMP API.
+ * See {@link https://docs.axelarscan.io/gmp} for the full shape — this helper
+ * surfaces just the status flags most useful for recovery decisions.
+ */
+export type AxelarGmpStatus = Readonly<{
+    /** Raw Axelar status — common values: "called", "confirming", "approved", "executed", "error". */
+    status: string;
+    /** Higher-level status — "received" when the message landed on the destination. */
+    simplifiedStatus?: string;
+    /** Did the destination-side execution succeed? */
+    executed: boolean;
+    /** Was the payload approved by Axelar validators? */
+    approved: boolean;
+    /** Destination-chain tx hash (if executed). */
+    destinationTxHash?: HexString;
+    /** Destination-chain block number (if executed). */
+    destinationBlockNumber?: number;
+    /** Underlying raw object — inspect for fields not surfaced above. */
+    raw: unknown;
+}>;
+
+/**
+ * Fetch the Axelar GMP status for a source-chain transaction that triggered
+ * an Axelar message (e.g. the Monad-side `MultiNTTWithExecutor.transfer`
+ * invocation).
+ *
+ * Returns `null` if Axelar has not yet indexed the transaction.
+ */
+export const fetchAxelarGmpStatus = async (
+    { sourceTxHash }: { sourceTxHash: HexString },
+    network: AxelarNetwork = "Mainnet",
+): Promise<AxelarGmpStatus | null> => {
+    const response = await fetch(`${getAxelarGmpApiUrl(network)}/gmp/searchGMP`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ txHash: sourceTxHash }),
+    });
+
+    if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`Axelar GMP status API returned ${response.status} ${response.statusText}: ${body}`);
+    }
+
+    const parsed = (await response.json()) as {
+        data?: Array<Record<string, unknown>>;
+    };
+    const entry = parsed.data?.[0];
+    if (!entry) return null;
+
+    const executedEntry = entry["executed"] as { transactionHash?: HexString; blockNumber?: number } | undefined;
+
+    return Object.freeze({
+        status: String(entry["status"] ?? "unknown"),
+        simplifiedStatus: entry["simplified_status"] as string | undefined,
+        executed: Boolean(entry["executed"]),
+        approved: Boolean(entry["approved"]),
+        destinationTxHash: executedEntry?.transactionHash,
+        destinationBlockNumber: executedEntry?.blockNumber,
+        raw: entry,
+    });
+};