@ember-finance/sdk 2.12.0-ccip.0 → 2.13.0

package/dist/src/placements/sui.js

@@ -0,0 +1,302 @@
+import { Batcher, ChunkTooLargeError, TransientError, isAbortError, isTransientStatus, retryAfterMs } from "./batch.js";
+const GRAPHQL_PAGE_SIZE = 50;
+/**
+ * Canonical form for a Sui coin type: `0x` stripped from the address segment,
+ * lowercased and left-padded to 64 hex chars.
+ *
+ * Object JSON returns unprefixed padded types ("0000..02::sui::SUI") while
+ * config and RPC use the short prefixed form ("0x2::sui::SUI"). Comparing the
+ * two without normalising silently never matches.
+ *
+ * Only the address is folded. It is hex, so case is not significant there, but
+ * the module and struct names are Move identifiers and two that differ only in
+ * case are two different types.
+ */
+export function normalizeCoinType(coinType) {
+    const parts = coinType.trim().split("::");
+    if (parts.length < 2)
+        return coinType.trim().toLowerCase();
+    const address = parts[0].toLowerCase().replace(/^0x/, "").padStart(64, "0");
+    return [address, ...parts.slice(1)].join("::");
+}
+export function coinTypesMatch(a, b) {
+    return normalizeCoinType(a) === normalizeCoinType(b);
+}
+/**
+ * A Sui address as GraphQL wants a dynamic-field key: base64 of its BCS
+ * encoding, which for an address is simply its 32 raw bytes.
+ */
+export function bcsAddress(address) {
+    // Hand-rolled rather than via Buffer, because this runs in the browser.
+    const hex = address.trim().replace(/^0x/, "").toLowerCase().padStart(64, "0");
+    if (!/^[0-9a-f]{64}$/.test(hex))
+        throw new Error(`not a sui address: ${address}`);
+    let binary = "";
+    for (let i = 0; i < hex.length; i += 2) {
+        binary += String.fromCharCode(Number.parseInt(hex.slice(i, i + 2), 16));
+    }
+    return btoa(binary);
+}
+/** Type arguments of a Move type, e.g. `Pool<A, B>` -> ["A", "B"]. */
+export function typeArguments(type) {
+    const open = type.indexOf("<");
+    if (open === -1 || !type.endsWith(">"))
+        return [];
+    const inner = type.slice(open + 1, -1);
+    const args = [];
+    let depth = 0;
+    let current = "";
+    for (const ch of inner) {
+        if (ch === "<")
+            depth++;
+        if (ch === ">")
+            depth--;
+        if (ch === "," && depth === 0) {
+            args.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim())
+        args.push(current.trim());
+    return args;
+}
+/** The object id a Move table's entries actually hang off. */
+export function tableId(field) {
+    // Protocols wrap tables to different depths — `{ id }`, `{ table: { id } }`,
+    // `{ table: { table: { id } } }` — and the outer id resolves to nothing, so
+    // reading it returns an empty field list rather than an error.
+    const nested = field;
+    return nested?.table?.table?.id ?? nested?.table?.id ?? nested?.id;
+}
+/**
+ * Some protocols wrap fixed-point numbers as `{ value }` scaled by 1e18.
+ * Returns base units, truncated — these feed balances, not accounting.
+ */
+export function decimalToBaseUnits(field) {
+    const raw = field?.value ?? field;
+    if (raw === undefined || raw === null)
+        return 0n;
+    return BigInt(String(raw)) / 1000000000000000000n;
+}
+export function toBigInt(field) {
+    if (field === undefined || field === null)
+        return 0n;
+    return BigInt(String(field));
+}
+export const DEFAULT_SUI_GRAPHQL_ENDPOINT = "https://graphql.mainnet.sui.io/graphql";
+const OBJECTS_ALIAS = "objects";
+const OBJECT_SELECTION = "{ address asMoveObject { contents { type { repr } json } } }";
+const OBJECT_KEY_WEIGHT = 0.25;
+const OBJECT_KEY_BYTES = 90;
+const SUI_ADDRESS = /^(0x)?[0-9a-fA-F]{1,64}$/;
+function normalizeAddress(address) {
+    return address.trim().toLowerCase().replace(/^0x/, "").padStart(64, "0");
+}
+function isSuiAddress(value) {
+    return SUI_ADDRESS.test(value.trim());
+}
+function literal(value) {
+    return JSON.stringify(value);
+}
+function buildDocument(chunk) {
+    const roots = [];
+    const ids = chunk.flatMap(item => (item.kind === "object" ? [item.id] : []));
+    if (ids.length > 0) {
+        const keys = ids.map(id => `{ address: ${literal(id)} }`).join(", ");
+        roots.push(`${OBJECTS_ALIAS}: multiGetObjects(keys: [${keys}]) ${OBJECT_SELECTION}`);
+    }
+    chunk.forEach((item, index) => {
+        if (item.kind === "field")
+            roots.push(`r${index}: ${item.field}`);
+    });
+    return `{ ${roots.join(" ")} }`;
+}
+function distribute(chunk, body) {
+    const aliasErrors = new Map();
+    const objectErrors = new Map();
+    const rootErrors = [];
+    for (const error of body.errors ?? []) {
+        const alias = error.path?.[0];
+        if (typeof alias !== "string") {
+            rootErrors.push(error.message);
+            continue;
+        }
+        const position = error.path?.[1];
+        if (alias === OBJECTS_ALIAS && typeof position === "number") {
+            objectErrors.set(position, error.message);
+        }
+        else {
+            aliasErrors.set(alias, error.message);
+        }
+    }
+    if (rootErrors.length > 0 || (body.data == null && (body.errors?.length ?? 0) > 0)) {
+        const message = `sui graphql: ${[...rootErrors, ...aliasErrors.values(), ...objectErrors.values()].join("; ")}`;
+        if (chunk.length > 1)
+            throw new ChunkTooLargeError(message);
+        throw new Error(message);
+    }
+    const data = body.data ?? {};
+    const objectsByAddress = new Map();
+    for (const node of data[OBJECTS_ALIAS] ?? []) {
+        const contents = node?.asMoveObject?.contents;
+        if (!node || !contents)
+            continue;
+        objectsByAddress.set(normalizeAddress(node.address), {
+            address: node.address,
+            type: contents.type.repr,
+            json: contents.json
+        });
+    }
+    let objectPosition = -1;
+    return chunk.map((item, index) => {
+        if (item.kind === "object") {
+            objectPosition += 1;
+            const message = objectErrors.get(objectPosition) ?? aliasErrors.get(OBJECTS_ALIAS);
+            if (message !== undefined) {
+                return { ok: false, error: new Error(`sui graphql: ${message}`) };
+            }
+            return { ok: true, value: objectsByAddress.get(normalizeAddress(item.id)) };
+        }
+        const alias = `r${index}`;
+        const message = aliasErrors.get(alias);
+        if (message !== undefined) {
+            return { ok: false, error: new Error(`sui graphql: ${message}`) };
+        }
+        return { ok: true, value: data[alias] };
+    });
+}
+export function graphqlSuiReader(options = {}) {
+    const config = typeof options === "string" ? { endpoint: options } : options;
+    const endpoint = config.endpoint ?? DEFAULT_SUI_GRAPHQL_ENDPOINT;
+    const fetchImpl = config.fetch ??
+        ((input, init) => globalThis.fetch(input, init));
+    const onRequest = config.onRequest;
+    const send = async (chunk, attempt) => {
+        const document = buildDocument(chunk);
+        let response;
+        try {
+            response = await fetchImpl(endpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ query: document }),
+                signal: config.signal
+            });
+        }
+        catch (error) {
+            if (isAbortError(error))
+                throw error;
+            onRequest?.({ items: chunk.length, attempt, status: "network-error" });
+            throw new TransientError(`sui graphql: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        onRequest?.({ items: chunk.length, attempt, status: response.status });
+        if (isTransientStatus(response.status)) {
+            throw new TransientError(`sui graphql ${response.status}`, retryAfterMs(response.headers?.get("retry-after")));
+        }
+        if (!response.ok) {
+            const message = `sui graphql ${response.status}`;
+            if (chunk.length > 1)
+                throw new ChunkTooLargeError(message);
+            throw new Error(message);
+        }
+        const body = (await response.json());
+        if (!body.data && !body.errors?.length) {
+            throw new Error("sui graphql: empty response");
+        }
+        return distribute(chunk, body);
+    };
+    const batcher = new Batcher({
+        send,
+        key: item => item.kind === "object" ? `object:${normalizeAddress(item.id)}` : item.field,
+        weight: item => (item.kind === "object" ? OBJECT_KEY_WEIGHT : 1),
+        bytes: item => (item.kind === "object" ? OBJECT_KEY_BYTES : item.field.length),
+        maxWeight: config.maxRootFields ?? 10,
+        maxBytes: config.maxBytes ?? 4500,
+        concurrency: config.concurrency,
+        retries: config.retries,
+        baseDelayMs: config.baseDelayMs,
+        maxDelayMs: config.maxDelayMs,
+        sleep: config.sleep,
+        signal: config.signal
+    });
+    const field = (gql) => batcher.enqueue({ kind: "field", field: gql });
+    const requireAddress = (value, what) => {
+        if (!isSuiAddress(value))
+            throw new Error(`sui graphql: ${what} is not a sui address`);
+    };
+    return {
+        async objects(ids) {
+            const unique = [...new Set(ids)];
+            for (const id of unique)
+                requireAddress(id, `object id ${id}`);
+            const found = await Promise.all(unique.map(id => batcher.enqueue({ kind: "object", id })));
+            const out = {};
+            for (const object of found) {
+                if (object)
+                    out[object.address] = object;
+            }
+            return out;
+        },
+        async balance(owner, coinType) {
+            requireAddress(owner, `owner ${owner}`);
+            const data = await field(`address(address: ${literal(owner)}) { balance(coinType: ${literal(coinType)}) { totalBalance } }`);
+            return data?.balance?.totalBalance ?? "0";
+        },
+        async ownedObjects(owner, type) {
+            requireAddress(owner, `owner ${owner}`);
+            const owned = [];
+            let cursor = null;
+            for (;;) {
+                const after = cursor ? `, after: ${literal(cursor)}` : "";
+                const page = await field(`address(address: ${literal(owner)}) { objects(first: ${GRAPHQL_PAGE_SIZE}${after}, filter: { type: ${literal(type)} }) { pageInfo { hasNextPage endCursor } nodes { address contents { type { repr } json } } } }`);
+                const container = page?.objects;
+                if (!container)
+                    break;
+                for (const node of container.nodes ?? []) {
+                    if (!node.contents)
+                        continue;
+                    owned.push({
+                        address: node.address,
+                        type: node.contents.type.repr,
+                        json: node.contents.json
+                    });
+                }
+                if (!container.pageInfo?.hasNextPage)
+                    break;
+                cursor = container.pageInfo.endCursor;
+            }
+            return owned;
+        },
+        async dynamicField(parentId, key) {
+            requireAddress(parentId, `parent ${parentId}`);
+            const data = await field(`address(address: ${literal(parentId)}) { dynamicField(name: { type: ${literal(key.type)}, bcs: ${literal(key.bcs)} }) { value { ... on MoveValue { json } } } }`);
+            return data?.dynamicField?.value?.json;
+        },
+        async dynamicFields(parentId, limit) {
+            requireAddress(parentId, `parent ${parentId}`);
+            const fields = [];
+            let cursor = null;
+            for (;;) {
+                const after = cursor ? `, after: ${literal(cursor)}` : "";
+                const page = await field(`address(address: ${literal(parentId)}) { dynamicFields(first: ${GRAPHQL_PAGE_SIZE}${after}) { pageInfo { hasNextPage endCursor } nodes { name { json } value { ... on MoveValue { type { repr } json } } } } }`);
+                const container = page?.dynamicFields;
+                if (!container)
+                    break;
+                for (const node of container.nodes ?? []) {
+                    fields.push({
+                        name: node.name?.json,
+                        valueType: node.value?.type?.repr ?? "",
+                        value: node.value?.json
+                    });
+                }
+                if (limit !== undefined && fields.length >= limit)
+                    break;
+                if (!container.pageInfo?.hasNextPage)
+                    break;
+                cursor = container.pageInfo.endCursor;
+            }
+            return limit === undefined ? fields : fields.slice(0, limit);
+        }
+    };
+}

package/dist/src/placements/types.d.ts

@@ -0,0 +1,147 @@
+import { ChainType } from "../common/constants.js";
+/** Identifier for a protocol adapter, e.g. "bluefin-spot". */
+export type ProtocolId = string;
+export interface ChainRef {
+    type: ChainType;
+    /** EVM network id. Absent on chains that have none. */
+    chainId?: number;
+    /** Chain identifier, e.g. "sui-mainnet". */
+    identifier?: string;
+}
+/** An Ember vault receipt coin, as listed by the vaults API. */
+export interface ReceiptCoin {
+    /** Sui coin type, or EVM token address. */
+    coin: string;
+    chain: ChainRef;
+    decimals: number;
+    symbol?: string;
+    /** Display name of the vault this coin belongs to. */
+    vault?: string;
+    /** RPC endpoint for this coin's chain, when one is published. */
+    rpcUrl?: string;
+}
+export type PointerOrigin = "Registry" | "Manual";
+/** Somewhere a receipt coin is listed. Carries no amount. */
+export interface PlacementRef {
+    /**
+     * Stable identity for this placement — the right thing to key a list on.
+     * A protocol can list the same coin at several venues (the same pair at two
+     * fee tiers, the two tranches of one market), so protocol and label
+     * together do not identify a row.
+     */
+    id?: string;
+    protocol: ProtocolId;
+    chain: ChainRef;
+    /** Pool, market or vault address. */
+    venue: string;
+    coin: string;
+    /** Decimals of `coin`. */
+    decimals: number;
+    /**
+     * The protocol's display name, e.g. "Current Finance". Absent when the
+     * vaults API has no catalogue entry — render `protocol` then.
+     */
+    protocolName?: string;
+    /** Icon for the protocol, when one is catalogued. */
+    protocolLogoUrl?: string;
+    source: PointerOrigin;
+    /** Human-readable venue name, for display only. */
+    label?: string;
+    /**
+     * The token an account holds for its position here, when that is not the
+     * venue itself. Defaults to `venue`.
+     */
+    shareToken?: string;
+    /** Deep link to the venue, for the caller to render. */
+    url?: string;
+    /**
+     * RPC endpoint for this chain, when one is published. Absent means fall
+     * back to whatever the reader was configured with.
+     */
+    rpcUrl?: string;
+}
+/** A resolved pointer: what one account holds there. */
+export interface Placement extends PlacementRef {
+    /** The account's own position, in base units of `coin`. */
+    amount: string;
+    readAt: string;
+}
+export interface PlacementFailure {
+    protocol: ProtocolId;
+    stage: "discover" | "read";
+    coin?: string;
+    reason: string;
+}
+/**
+ * One vault's shares for one account.
+ *
+ * A non-empty `failures` means `placements` is incomplete — a caller showing a
+ * total should say so rather than quietly under-report.
+ */
+export interface AccountShares {
+    vaultId: string;
+    coin: ReceiptCoin;
+    /** Held in the account's own wallet. Base units of `coin`. */
+    available: string;
+    /** Wrapped into a cover vault. Absent when the vault is not covered. */
+    covered?: string;
+    placements: Placement[];
+    failures: PlacementFailure[];
+    unresolved?: true;
+}
+export interface SuiObjectContents {
+    address: string;
+    type: string;
+    json: Record<string, unknown>;
+}
+export interface SuiDynamicField {
+    name: unknown;
+    valueType: string;
+    value: unknown;
+}
+/** Narrow read port over Sui, so a caller can supply its own transport. */
+export interface SuiReader {
+    objects(ids: string[]): Promise<Record<string, SuiObjectContents>>;
+    dynamicFields(parentId: string, limit?: number): Promise<SuiDynamicField[]>;
+    /**
+     * One dynamic field addressed by its BCS-encoded key. Resolves to undefined
+     * when the key is absent.
+     */
+    dynamicField(parentId: string, key: {
+        type: string;
+        bcs: string;
+    }): Promise<unknown | undefined>;
+    /** Total balance an address holds of one coin type, in base units. */
+    balance(owner: string, coinType: string): Promise<string>;
+    /** Objects of one type owned by an address. */
+    ownedObjects(owner: string, type: string): Promise<SuiObjectContents[]>;
+}
+/** Narrow read port over EVM: one `eth_call` is all these reads need. */
+export interface EvmReader {
+    /** `endpoint`, when given, overrides whatever the reader is configured with. */
+    call(chainId: number, to: string, data: string, endpoint?: string): Promise<string>;
+}
+/** Where pointers come from. */
+export interface PointerSource {
+    placements(protocol: ProtocolId, coin: ReceiptCoin): Promise<PlacementRef[]>;
+}
+/** Resolves a vault to the receipt coins it issues, one per chain it runs on. */
+export interface VaultCoinsResolver {
+    coinsForVault(vaultId: string): Promise<ReceiptCoin[]>;
+    coverVault?(coin: ReceiptCoin): Promise<string | undefined>;
+}
+export interface PlacementsContext {
+    sui?: SuiReader;
+    evm?: EvmReader;
+    pointers: PointerSource;
+    vaults?: VaultCoinsResolver;
+}
+/** The extension seam. One protocol, registered with `registerAdapter`. */
+export interface ProtocolAdapter {
+    readonly id: ProtocolId;
+    readonly chain: ChainType;
+    /** Pointers only, carrying no amounts. */
+    discover(coin: ReceiptCoin, ctx: PlacementsContext): Promise<PlacementRef[]>;
+    /** What `account` holds at each venue, in base units of `ref.coin`. */
+    read(refs: PlacementRef[], account: string, ctx: PlacementsContext): Promise<Placement[]>;
+}

package/dist/src/placements/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/placements/vaults.d.ts

@@ -0,0 +1,15 @@
+import { PlatformEnv } from "../common/constants.js";
+import { VaultCoinsResolver } from "./types.js";
+export interface HttpVaultCoinsOptions {
+    /** Vaults API environment. Defaults to prod. */
+    env?: PlatformEnv;
+    /** Overrides `env` entirely. For a local deployment, or a proxy. */
+    baseUrl?: string;
+}
+/**
+ * Resolves a vault to the receipt coins it issues, from the vaults API.
+ *
+ * A vault runs on one or more chains and issues a distinct receipt coin on
+ * each, so this returns one entry per chain rather than assuming a single coin.
+ */
+export declare function httpVaultCoinsResolver(options?: HttpVaultCoinsOptions): VaultCoinsResolver;

package/dist/src/placements/vaults.js

@@ -0,0 +1,97 @@
+import { environmentConfig } from "../common/constants.js";
+/**
+ * Resolves a vault to the receipt coins it issues, from the vaults API.
+ *
+ * A vault runs on one or more chains and issues a distinct receipt coin on
+ * each, so this returns one entry per chain rather than assuming a single coin.
+ */
+export function httpVaultCoinsResolver(options = {}) {
+    const baseUrl = (options.baseUrl ?? environmentConfig[options.env ?? "prod"].apiHost).replace(/\/$/, "");
+    const get = async (path) => {
+        const response = await fetch(`${baseUrl}${path}`, {
+            headers: { Accept: "application/json" }
+        });
+        if (!response.ok)
+            throw new Error(`vaults api ${response.status} for ${path}`);
+        return (await response.json());
+    };
+    // The chain catalogue is what carries the EVM network id. Without it an EVM
+    // coin has no chainId, and every read for it fails rather than returning a
+    // balance — so this is fetched once and shared, not guessed per coin.
+    let chains;
+    const chainRefs = () => {
+        if (chains)
+            return chains;
+        chains = get("/api/v2/vaults/supported-chains").then(supported => {
+            const byIdentifier = new Map();
+            for (const chain of supported) {
+                if (!chain.identifier)
+                    continue;
+                byIdentifier.set(chain.identifier.toLowerCase(), {
+                    type: chain.type?.toUpperCase() === "SUI" ? "sui" : "evm",
+                    chainId: chain.networkId,
+                    identifier: chain.identifier,
+                    rpcUrl: chain.publicRpcUrl
+                });
+            }
+            return byIdentifier;
+        });
+        // Cache the value, not the rejection: one transient 502 here would
+        // otherwise fail every later call on this resolver for good.
+        chains.catch(() => {
+            chains = undefined;
+        });
+        return chains;
+    };
+    /** Falls back to the identifier's shape when the catalogue has no entry. */
+    const chainRefFor = (identifier, catalogue) => catalogue.get(identifier.toLowerCase()) ?? {
+        type: identifier.toLowerCase().startsWith("sui") ? "sui" : "evm",
+        identifier
+    };
+    return {
+        async coinsForVault(vaultId) {
+            const [vaults, catalogue] = await Promise.all([
+                get(`/api/v2/vaults?vaultId=${encodeURIComponent(vaultId)}`),
+                chainRefs()
+            ]);
+            const list = Array.isArray(vaults) ? vaults : [vaults];
+            const vault = list.find(v => v.id === vaultId) ?? list[0];
+            if (!vault)
+                throw new Error(`vault ${vaultId} not found`);
+            // An ATOMIC vault has no receipt token, but the API still fills
+            // receiptCoin with a placeholder so the field never breaks older
+            // consumers. Reading it would hand back a coin that does not exist.
+            if (vault.vaultType === "ATOMIC") {
+                throw new Error(`vault ${vaultId} is atomic and issues no receipt coin`);
+            }
+            const coins = [];
+            for (const [identifier, details] of Object.entries(vault.detailsByChain ?? {})) {
+                const receipt = details.receiptCoin;
+                if (!receipt?.address)
+                    continue;
+                if (typeof receipt.decimals !== "number") {
+                    throw new Error(`${receipt.address} has no decimals`);
+                }
+                const { rpcUrl, ...chain } = chainRefFor(details.chainIdentifier ?? identifier, catalogue);
+                coins.push({
+                    coin: receipt.address,
+                    chain,
+                    decimals: receipt.decimals,
+                    // The wallet balance is not a placement, so it has no
+                    // pointer to borrow an endpoint from. Carry the published
+                    // one here or the caller must configure every chain itself.
+                    rpcUrl,
+                    symbol: receipt.symbol,
+                    // longName is empty on every vault the API returns
+                    // today, and "" is not nullish — ?? would keep it and
+                    // hand the caller a blank name to render.
+                    vault: vault.longName || vault.name
+                });
+            }
+            if (coins.length === 0) {
+                throw new Error(`vault ${vaultId} issues no receipt coin`);
+            }
+            return coins;
+        }
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@ember-finance/sdk",
     "description": "Ember Protocol SDK",
-    "version": "2.12.0-ccip.0",
+    "version": "2.13.0",
     "type": "module",
     "module": "./dist/index.js",
     "main": "./dist/index.js",
@@ -44,6 +44,11 @@
             "import": "./dist/src/common/index.js",
             "default": "./dist/src/common/index.js"
         },
+        "./placements": {
+            "types": "./dist/src/placements/index.d.ts",
+            "import": "./dist/src/placements/index.js",
+            "default": "./dist/src/placements/index.js"
+        },
         "./abis": {
             "types": "./dist/src/abis/index.d.ts",
             "import": "./dist/src/abis/index.js",

package/dist/src/abis/CcipRouter.json

@@ -1,58 +0,0 @@
-{
-    "abi": [
-        {
-            "type": "function",
-            "name": "getFee",
-            "stateMutability": "view",
-            "inputs": [
-                { "name": "destChainSelector", "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" }
-                    ]
-                }
-            ],
-            "outputs": [{ "name": "fee", "type": "uint256" }]
-        },
-        {
-            "type": "function",
-            "name": "ccipSend",
-            "stateMutability": "payable",
-            "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" }
-                    ]
-                }
-            ],
-            "outputs": [{ "name": "messageId", "type": "bytes32" }]
-        }
-    ]
-}