otto-intel-mcp 0.1.0

package/dist/hyperliquid-order-assertions.js

@@ -0,0 +1,325 @@
+import { HYPERLIQUID_ACTION_KEY_ORDER, HYPERLIQUID_AGENT_EIP712_FIELDS, HYPERLIQUID_AGENT_PRIMARY_TYPE, HYPERLIQUID_EIP712_DOMAIN_NAME, HYPERLIQUID_EIP712_DOMAIN_VERSION, HYPERLIQUID_EIP712_VERIFYING_CONTRACT, HYPERLIQUID_L1_SIGNATURE_CHAIN_ID, HYPERLIQUID_MAINNET_AGENT_SOURCE, HYPERLIQUID_ORDER_KEY_ORDER, HYPERLIQUID_PERP_MAX_DECIMALS, HYPERLIQUID_PRICE_MAX_SIGNIFICANT_DIGITS, HYPERLIQUID_TRIGGER_KEY_ORDER, } from './execution-config.js';
+import { refuse } from './execution-errors.js';
+/**
+ * Assert-what-you-built for the Hyperliquid rail (spec §8.2): every check below runs on the action the
+ * venue's own normalizer actually produced — the object whose msgpack bytes enter the digest the
+ * user's signer will sign — never on the values this constructor intended to build.
+ */
+function orderRefuse(message) {
+    return refuse('HYPERLIQUID_ORDER_INVALID', message);
+}
+function marketRefuse(message) {
+    return refuse('UNSUPPORTED_HYPERLIQUID_MARKET', message);
+}
+/**
+ * Parse an exact decimal string. The caller's string form is authoritative and is what lands in the
+ * signed action verbatim: no float ever touches a price or a size here.
+ *
+ * This is the deliberate divergence from the trade-execution agent, which formats prices through
+ * `parseFloat(price.toPrecision(5))` and `Math.floor(price * 10 ** d) / 10 ** d`
+ * (`hyperliquid-client.ts:55,1291`) and sizes through `size.toFixed(szDecimals)`. Those ROUND, and two
+ * of them round differently from each other. Rounding is acceptable when a caller's intent is "fill me
+ * around here" and the round trip is milliseconds; it is not acceptable in a prepare-only artifact the
+ * caller signs later, because the price they signed would not be the price they named. So the grid is
+ * extracted as a VALIDATION and an off-grid request is refused by name.
+ */
+export function hyperliquidDecimal(value) {
+    const match = /^(0|[1-9]\d*)(?:\.(\d*[1-9]))?$/.exec(value);
+    if (!match) {
+        marketRefuse(`${value} is not a normalized decimal (no leading zeros, no trailing zeros after the point)`);
+    }
+    const [, whole, fraction] = match;
+    const digits = `${whole}${fraction ?? ''}`.replace(/^0+/, '');
+    return Object.freeze({
+        raw: value,
+        decimals: fraction?.length ?? 0,
+        isInteger: fraction === undefined,
+        significantDigits: digits.length,
+    });
+}
+/** Exact scaled integer for comparison. Refuses rather than truncating excess precision. */
+export function hyperliquidScaledUnits(value, decimals) {
+    const parsed = hyperliquidDecimal(value);
+    if (parsed.decimals > decimals) {
+        orderRefuse(`${value} carries more precision than ${decimals} decimal places`);
+    }
+    const [whole, fraction = ''] = value.split('.');
+    return BigInt(`${whole}${fraction.padEnd(decimals, '0')}`);
+}
+/** Fractional digits the venue accepts in a perp price for this asset: `MAX_DECIMALS - szDecimals`. */
+export function hyperliquidMaxPriceDecimals(szDecimals) {
+    return Math.max(HYPERLIQUID_PERP_MAX_DECIMALS - szDecimals, 0);
+}
+/**
+ * The venue's perp price grid: at most `MAX_DECIMALS - szDecimals` fractional digits AND at most 5
+ * significant digits, with integer prices always accepted regardless of significant figures.
+ */
+export function assertHyperliquidPriceOnGrid(price, szDecimals) {
+    const parsed = hyperliquidDecimal(price);
+    if (parsed.raw === '0')
+        marketRefuse('price must be greater than zero');
+    const maxDecimals = hyperliquidMaxPriceDecimals(szDecimals);
+    if (parsed.decimals > maxDecimals) {
+        marketRefuse(`price ${price} carries ${parsed.decimals} decimal places; this perp accepts at most ${maxDecimals} (6 - szDecimals ${szDecimals})`);
+    }
+    if (!parsed.isInteger && parsed.significantDigits > HYPERLIQUID_PRICE_MAX_SIGNIFICANT_DIGITS) {
+        marketRefuse(`price ${price} carries ${parsed.significantDigits} significant digits; the venue accepts at most ${HYPERLIQUID_PRICE_MAX_SIGNIFICANT_DIGITS} for a non-integer price`);
+    }
+    return parsed;
+}
+/** The venue's size grid: at most `szDecimals` fractional digits, strictly positive. */
+export function assertHyperliquidSizeOnGrid(size, szDecimals) {
+    const parsed = hyperliquidDecimal(size);
+    if (parsed.raw === '0')
+        marketRefuse('size must be greater than zero');
+    if (parsed.decimals > szDecimals) {
+        marketRefuse(`size ${size} carries ${parsed.decimals} decimal places; this perp accepts at most szDecimals ${szDecimals}`);
+    }
+    return parsed;
+}
+/**
+ * A take-profit below the entry on a long — or above it on a short — is not a take-profit: it is an
+ * instruction to close at a loss the moment the entry fills, and the same inversion on the stop-loss
+ * leg arms an immediate close. The venue accepts both, and the trade-execution agent does not check
+ * either (`hyperliquid-client.ts:1829,1851`). An inverted bracket is a defect in the REQUEST, so
+ * naming it is P0-clean (§7.0): a coherent bracket always constructs.
+ */
+export function assertHyperliquidBracketCoherent(input) {
+    const decimals = hyperliquidMaxPriceDecimals(input.szDecimals);
+    const entry = hyperliquidScaledUnits(input.price, decimals);
+    if (input.takeProfitPrice !== undefined) {
+        const takeProfit = hyperliquidScaledUnits(input.takeProfitPrice, decimals);
+        const coherent = input.isBuy ? takeProfit > entry : takeProfit < entry;
+        if (!coherent) {
+            marketRefuse(`take profit ${input.takeProfitPrice} is not ${input.isBuy ? 'above' : 'below'} the ${input.isBuy ? 'long' : 'short'} entry ${input.price}; it would close the position at a loss on fill`);
+        }
+    }
+    if (input.stopLossPrice !== undefined) {
+        const stopLoss = hyperliquidScaledUnits(input.stopLossPrice, decimals);
+        const coherent = input.isBuy ? stopLoss < entry : stopLoss > entry;
+        if (!coherent) {
+            marketRefuse(`stop loss ${input.stopLossPrice} is not ${input.isBuy ? 'below' : 'above'} the ${input.isBuy ? 'long' : 'short'} entry ${input.price}; it would trigger immediately on fill`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------------------------
+// Decode-back over the SDK-normalized action
+// ---------------------------------------------------------------------------------------------
+const CLIENT_ORDER_ID_PATTERN = /^0x[0-9a-f]{32}$/;
+function keyOrderOf(value, expected, what) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        orderRefuse(`constructed Hyperliquid ${what} is not an object`);
+    }
+    const actual = Object.keys(value);
+    if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+        // msgpack encodes keys in insertion order, so this is not cosmetic: a reordered action hashes to
+        // a different connectionId and the signature the user produced would authorize nothing.
+        orderRefuse(`constructed Hyperliquid ${what} key order is [${actual.join(',')}], not the canonical [${expected.join(',')}]`);
+    }
+}
+function requiredString(source, key, what) {
+    const value = source[key];
+    if (typeof value !== 'string' || value.length === 0) {
+        orderRefuse(`constructed Hyperliquid ${what} is missing a string ${key}`);
+    }
+    return value;
+}
+function requiredBoolean(source, key, what) {
+    const value = source[key];
+    if (typeof value !== 'boolean') {
+        orderRefuse(`constructed Hyperliquid ${what} is missing a boolean ${key}`);
+    }
+    return value;
+}
+/**
+ * Decode the normalizer's output back into a strictly typed action and assert every fund-critical
+ * field: the positional asset id, the exact price and size strings, the side, reduce-only, the trigger
+ * shape, the per-leg client order ids, the grouping, the canonical key order, and the ABSENCE of the
+ * builder key (the ruled valueless state, spec §7.2).
+ */
+export function decodeAndAssertHyperliquidAction(input) {
+    const raw = input.built.action;
+    keyOrderOf(raw, HYPERLIQUID_ACTION_KEY_ORDER, 'action');
+    if (raw.type !== 'order') {
+        orderRefuse('constructed Hyperliquid action is not an order action');
+    }
+    // The builder key carries Otto's attribution and its VALUE is an open Founder ruling (spec §7.2).
+    // Its absence is therefore asserted, not tolerated: a builder key here would mean an unruled
+    // address or fee rate had entered the bytes the user signs.
+    if ('builder' in raw) {
+        orderRefuse('constructed Hyperliquid action carries a builder field; the builder value is unruled until the Step-0 approveBuilderFee reversal lands');
+    }
+    if (raw.grouping !== input.grouping) {
+        orderRefuse(`constructed Hyperliquid action grouping is ${String(raw.grouping)}, not the expected ${input.grouping}`);
+    }
+    const orders = raw.orders;
+    if (!Array.isArray(orders) || orders.length !== input.legs.length) {
+        orderRefuse(`constructed Hyperliquid action carries ${Array.isArray(orders) ? orders.length : 0} legs, not the expected ${input.legs.length}`);
+    }
+    const seenClientOrderIds = new Set();
+    const decodedLegs = [];
+    for (const [index, expected] of input.legs.entries()) {
+        const leg = orders[index];
+        keyOrderOf(leg, [...HYPERLIQUID_ORDER_KEY_ORDER, 'c'], `${expected.role} leg`);
+        if (leg.a !== input.asset.assetId) {
+            // The asset id is the POSITION in the live perp universe. A wrong index is a different market.
+            refuse('ACCOUNT_BINDING_MISMATCH', `constructed Hyperliquid ${expected.role} leg names asset id ${String(leg.a)}, not ${input.asset.assetId} (${input.asset.name})`);
+        }
+        if (requiredBoolean(leg, 'b', `${expected.role} leg`) !== expected.isBuy) {
+            orderRefuse(`constructed Hyperliquid ${expected.role} leg is on the wrong side`);
+        }
+        const price = requiredString(leg, 'p', `${expected.role} leg`);
+        const size = requiredString(leg, 's', `${expected.role} leg`);
+        if (price !== expected.price) {
+            orderRefuse(`constructed Hyperliquid ${expected.role} leg is priced ${price}, not the requested ${expected.price}`);
+        }
+        if (size !== expected.size) {
+            orderRefuse(`constructed Hyperliquid ${expected.role} leg is sized ${size}, not the requested ${expected.size}`);
+        }
+        if (requiredBoolean(leg, 'r', `${expected.role} leg`) !== expected.reduceOnly) {
+            orderRefuse(`constructed Hyperliquid ${expected.role} leg has the wrong reduce-only flag`);
+        }
+        const clientOrderId = requiredString(leg, 'c', `${expected.role} leg`);
+        if (!CLIENT_ORDER_ID_PATTERN.test(clientOrderId)) {
+            orderRefuse(`constructed Hyperliquid ${expected.role} leg carries a malformed client order id`);
+        }
+        if (clientOrderId !== expected.clientOrderId) {
+            orderRefuse(`constructed Hyperliquid ${expected.role} leg carries a client order id this constructor did not mint`);
+        }
+        if (seenClientOrderIds.has(clientOrderId)) {
+            // Two legs sharing an id is exactly what forces a positional read of the venue's response, the
+            // failure mode `hyperliquid-client.ts:1801` documents.
+            orderRefuse('constructed Hyperliquid action reuses a client order id across legs');
+        }
+        seenClientOrderIds.add(clientOrderId);
+        const orderType = leg.t;
+        if (orderType === null || typeof orderType !== 'object') {
+            orderRefuse(`constructed Hyperliquid ${expected.role} leg has no order type`);
+        }
+        const typeKeys = Object.keys(orderType);
+        if (expected.trigger) {
+            if (typeKeys.length !== 1 || typeKeys[0] !== 'trigger') {
+                orderRefuse(`constructed Hyperliquid ${expected.role} leg is not a trigger order`);
+            }
+            const trigger = orderType.trigger;
+            keyOrderOf(trigger, HYPERLIQUID_TRIGGER_KEY_ORDER, `${expected.role} trigger`);
+            const triggerRecord = trigger;
+            // `isMarket: true` is what makes the trigger close the position at the market once armed; a
+            // limit trigger can arm and never fill, leaving the bracket the caller asked for unenforced.
+            if (triggerRecord.isMarket !== true) {
+                orderRefuse(`constructed Hyperliquid ${expected.role} trigger is not a market trigger`);
+            }
+            if (requiredString(triggerRecord, 'triggerPx', `${expected.role} trigger`) !== expected.trigger.triggerPx) {
+                orderRefuse(`constructed Hyperliquid ${expected.role} trigger price is not the requested ${expected.trigger.triggerPx}`);
+            }
+            if (triggerRecord.tpsl !== expected.trigger.tpsl) {
+                orderRefuse(`constructed Hyperliquid ${expected.role} trigger is not tagged ${expected.trigger.tpsl}`);
+            }
+            decodedLegs.push({
+                a: input.asset.assetId,
+                b: expected.isBuy,
+                p: price,
+                s: size,
+                r: expected.reduceOnly,
+                t: {
+                    trigger: {
+                        isMarket: true,
+                        triggerPx: expected.trigger.triggerPx,
+                        tpsl: expected.trigger.tpsl,
+                    },
+                },
+                c: clientOrderId,
+            });
+            continue;
+        }
+        if (typeKeys.length !== 1 || typeKeys[0] !== 'limit') {
+            orderRefuse(`constructed Hyperliquid ${expected.role} leg is not a limit order`);
+        }
+        const limit = orderType.limit;
+        keyOrderOf(limit, ['tif'], `${expected.role} limit`);
+        if (limit.tif !== expected.tif) {
+            orderRefuse(`constructed Hyperliquid ${expected.role} leg time-in-force is not the requested ${String(expected.tif)}`);
+        }
+        decodedLegs.push({
+            a: input.asset.assetId,
+            b: expected.isBuy,
+            p: price,
+            s: size,
+            r: expected.reduceOnly,
+            t: { limit: { tif: expected.tif } },
+            c: clientOrderId,
+        });
+    }
+    // Rebuild the action from the asserted values, in the canonical key order, and require it to
+    // serialize byte-for-byte identically to what the venue's normalizer produced. msgpack is
+    // order-sensitive, so equality of the JSON SERIALIZATION — not merely of the values — is what ties
+    // the published action to the bytes the signature will cover.
+    //
+    // Honest note on this specific line: it has no reachable mutant today. Every field, key order, and
+    // key-set check above runs first, so any single-field mutation of a real normalized action is killed
+    // before reaching here (`hyperliquid-order-mutation-proof.ts` demonstrates that for 26 action
+    // mutants). It is kept deliberately as a forward guard: the moment a future field is added to the
+    // rebuild without a matching decode-back check, this line is what fails instead of shipping an
+    // artifact whose published action differs from the asserted one. The reddenable part of
+    // `hyperliquid_action_matches_venue_schema` is the venue-schema parse itself, which the mutation
+    // proof exercises directly against `buildUnsignedHyperliquidOrderAction`.
+    const action = {
+        type: 'order',
+        orders: decodedLegs,
+        grouping: input.grouping,
+    };
+    if (JSON.stringify(action) !== JSON.stringify(raw)) {
+        orderRefuse('re-derived Hyperliquid action does not serialize identically to the action the venue schema produced');
+    }
+    return Object.freeze({
+        action,
+        assertions: Object.freeze([
+            { id: 'hyperliquid_asset_index_from_live_meta', result: 'passed' },
+            { id: 'hyperliquid_price_on_venue_grid', result: 'passed' },
+            { id: 'hyperliquid_size_within_sz_decimals', result: 'passed' },
+            { id: 'hyperliquid_order_sides_bound', result: 'passed' },
+            { id: 'hyperliquid_grouping_matches_legs', result: 'passed' },
+            { id: 'hyperliquid_client_order_ids_distinct', result: 'passed' },
+            { id: 'hyperliquid_action_key_order_canonical', result: 'passed' },
+            { id: 'hyperliquid_action_matches_venue_schema', result: 'passed' },
+            { id: 'hyperliquid_builder_absent_pending_step0', result: 'passed' },
+            { id: 'hyperliquid_action_carries_no_nonce', result: 'passed' },
+        ]),
+    });
+}
+/**
+ * The signing declaration: exactly the domain, struct, primary type, and `source` the venue's own
+ * signer uses (`@nktkas/hyperliquid` signing/mod.js:170-189), plus the `connectionId` recipe.
+ *
+ * `connectionId` itself is NOT published, and cannot be: it is
+ * `keccak256(msgpack(action) ++ nonce ++ vault ++ expiresAfter)` and the nonce is adapter-owned
+ * (§6/§10). Pre-committing a nonce here is precisely what would turn a correct artifact into a stale
+ * or replayable one, so the artifact publishes the preimage layout and leaves the nonce to the signer.
+ */
+export function hyperliquidSigningDeclaration() {
+    return {
+        scheme: 'hyperliquid_l1_agent_eip712',
+        primary_type: HYPERLIQUID_AGENT_PRIMARY_TYPE,
+        domain: {
+            name: HYPERLIQUID_EIP712_DOMAIN_NAME,
+            version: HYPERLIQUID_EIP712_DOMAIN_VERSION,
+            chainId: HYPERLIQUID_L1_SIGNATURE_CHAIN_ID,
+            verifyingContract: HYPERLIQUID_EIP712_VERIFYING_CONTRACT,
+        },
+        types: { Agent: HYPERLIQUID_AGENT_EIP712_FIELDS.map((field) => ({ ...field })) },
+        source: HYPERLIQUID_MAINNET_AGENT_SOURCE,
+        connection_id: {
+            hash: 'keccak256',
+            preimage: [
+                'msgpack(action)',
+                'nonce_uint64_be',
+                'vault_address_marker',
+                'vault_address_bytes',
+                'expires_after_marker',
+                'expires_after_uint64_be',
+            ],
+            nonce_owner: 'adapter',
+        },
+    };
+}
+//# sourceMappingURL=hyperliquid-order-assertions.js.map

package/dist/hyperliquid-order-builder.d.ts

@@ -0,0 +1,47 @@
+import { type HyperliquidOrderGrouping, type HyperliquidTimeInForce } from './execution-config.js';
+export type HyperliquidOrderKind = {
+    readonly limit: {
+        readonly tif: HyperliquidTimeInForce;
+    };
+} | {
+    readonly trigger: {
+        readonly isMarket: boolean;
+        readonly triggerPx: string;
+        readonly tpsl: 'tp' | 'sl';
+    };
+};
+export interface HyperliquidOrderLegRequest {
+    /** Positional index in the live perp universe; never a value this repo invents. */
+    readonly assetId: number;
+    readonly isBuy: boolean;
+    /** Exact decimal price string, already validated against the venue grid by the caller. */
+    readonly price: string;
+    /** Exact decimal size string, already validated against `szDecimals` by the caller. */
+    readonly size: string;
+    readonly reduceOnly: boolean;
+    readonly orderType: HyperliquidOrderKind;
+    /** Constructor-minted, one distinct id per leg, so no leg is correlated positionally. */
+    readonly clientOrderId: string;
+}
+/**
+ * NOTE the fields this request type deliberately does NOT have: `builder`, `nonce`, `signature`,
+ * `vaultAddress`, `expiresAfter`. Attribution has no caller seam (§5) and is valueless today (§7.2);
+ * the nonce and the final request serialization are adapter-owned (§6/§10); the vault address is a
+ * declared profile fact recorded in the envelope, not something the action carries.
+ */
+export interface UnsignedHyperliquidActionRequest {
+    readonly legs: readonly HyperliquidOrderLegRequest[];
+    readonly grouping: HyperliquidOrderGrouping;
+}
+export interface UnsignedHyperliquidAction {
+    /** The SDK's own normalized action, in the SDK's own key order. */
+    readonly action: Record<string, unknown>;
+}
+/**
+ * Run the venue's own normalizer over the requested legs and return the canonical action.
+ *
+ * `v.object` DROPS keys the venue schema does not declare, which is the "canonicalize declared
+ * fields, strip undeclared" rule the CDP sitting made mandatory (spec §12, C2x row) applied at the
+ * action layer: whatever this function returns contains only fields the venue itself declares.
+ */
+export declare function buildUnsignedHyperliquidOrderAction(request: UnsignedHyperliquidActionRequest): UnsignedHyperliquidAction;

package/dist/hyperliquid-order-builder.js

@@ -0,0 +1,55 @@
+import { OrderRequest } from '@nktkas/hyperliquid/api/exchange';
+import * as v from 'valibot';
+import { refuse } from './execution-errors.js';
+/**
+ * Drives `@nktkas/hyperliquid`'s OWN action normalizer and stops before signing (spec §7.2: extract
+ * by behavior from `hyperliquid-client.ts`, excluding wallet creation, signing, and submission).
+ *
+ * The prepare-only split is structural, not a matter of discipline. This module imports exactly one
+ * thing from the SDK — the `order` action's valibot schema — and nothing from `signing/mod.js`,
+ * `HttpTransport`, or `ExchangeClient`. There is no wallet in scope, so there is nothing here that
+ * could sign or submit, and the root-secret-derived agent wallet (`hyperliquid-client.ts:558`) is not
+ * reachable from this file at all.
+ *
+ * Why the SDK's normalizer rather than a hand-built object: the signature commits to
+ * `keccak256(msgpack(action) ++ …)`, and msgpack serializes object keys in INSERTION order. The
+ * normalizer's output key order therefore IS part of the signed bytes. Running the venue's own schema
+ * is what makes the artifact's action byte-identical to what the SDK would have sent, instead of
+ * merely value-equal to it.
+ */
+/** The venue's action schema minus the discriminator, exactly as the SDK's `order()` derives it. */
+const HYPERLIQUID_ORDER_PARAMETERS = v.omit(v.object(OrderRequest.entries.action.entries), ['type']);
+/**
+ * Run the venue's own normalizer over the requested legs and return the canonical action.
+ *
+ * `v.object` DROPS keys the venue schema does not declare, which is the "canonicalize declared
+ * fields, strip undeclared" rule the CDP sitting made mandatory (spec §12, C2x row) applied at the
+ * action layer: whatever this function returns contains only fields the venue itself declares.
+ */
+export function buildUnsignedHyperliquidOrderAction(request) {
+    if (request.legs.length === 0) {
+        return refuse('HYPERLIQUID_ORDER_INVALID', 'Hyperliquid action must carry at least one order leg');
+    }
+    let normalized;
+    try {
+        normalized = v.parse(HYPERLIQUID_ORDER_PARAMETERS, {
+            orders: request.legs.map((leg) => ({
+                a: leg.assetId,
+                b: leg.isBuy,
+                p: leg.price,
+                s: leg.size,
+                r: leg.reduceOnly,
+                t: leg.orderType,
+                c: leg.clientOrderId,
+            })),
+            grouping: request.grouping,
+        });
+    }
+    catch (error) {
+        return refuse('HYPERLIQUID_ORDER_INVALID', `Hyperliquid order action failed the venue schema: ${error instanceof Error ? error.message : 'unknown error'}`);
+    }
+    // `type` first is the SDK's own composition (`api/exchange/_methods/order.js:193`), and it is part
+    // of the msgpacked bytes, so it is reproduced here rather than appended afterwards.
+    return Object.freeze({ action: { type: 'order', ...normalized } });
+}
+//# sourceMappingURL=hyperliquid-order-builder.js.map

package/dist/lifi-bridge-assertions.d.ts

@@ -0,0 +1,49 @@
+import { type Address, type Hex } from 'viem';
+import { type ExecutionServiceConfig } from './execution-config.js';
+import type { AccountProfile, ExecutionAssertion } from './execution-types.js';
+import type { LiFiQuote } from './lifi-execution-client.js';
+/** The enumerated v1 bridge facet. Anything else — eco, stargate, a plain no-swap layout, or a
+ *  post-redeploy selector — is outside the reviewed set and refused by name. */
+export declare const LIFI_BRIDGE_SELECTORS: Readonly<{
+    polymerCctp: Hex;
+}>;
+export interface LiFiBridgeAssertionInput {
+    readonly quote: LiFiQuote;
+    readonly profile: AccountProfile;
+    readonly fromChainId: number;
+    readonly toChainId: number;
+    readonly fromToken: Address;
+    readonly toToken: Address;
+    readonly fromAmount: bigint;
+    /**
+     * Where the destination mint lands — `BridgeData.receiver`, the field CCTP actually mints to,
+     * and the quote's `toAddress`. It is deliberately NOT bound to the PolymerData refund field,
+     * which carries the sender: see the tuple comment. It need not equal `profile.address`.
+     */
+    readonly destinationRecipient: Address;
+    readonly maxSlippageBps: number;
+    readonly minAmountOut?: bigint;
+    readonly config: ExecutionServiceConfig;
+}
+export interface AssertedLiFiBridge {
+    readonly approvalSpender: Address;
+    readonly transaction: {
+        readonly to: Address;
+        readonly value: '0';
+        readonly data: Hex;
+    };
+    /** The net amount the destination chain mints, after the reviewed fee legs. */
+    readonly destinationMinAmount: bigint;
+    readonly assertions: readonly ExecutionAssertion[];
+}
+/**
+ * Decode the constructed bridge calldata and assert every fund-safety bind, fail-closed.
+ *
+ * The destination binds matter more here than on a same-chain swap: a wrong destination recipient
+ * is an irreversible cross-chain loss, and the source-chain calldata is the last place it is
+ * checkable. CCTP burns the source USDC and mints canonical USDC to `BridgeData.receiver` on the
+ * destination, so the destination asset is same-token by construction once the facet and the
+ * enumerated route are pinned — that, plus every recipient-shaped field being bound, is what makes
+ * the destination side assertable from source calldata alone.
+ */
+export declare function decodeAndAssertLiFiBridge(input: LiFiBridgeAssertionInput): AssertedLiFiBridge;