otto-intel-mcp 0.1.2 → 0.1.4

package/dist/yield-deposit.js

@@ -0,0 +1,149 @@
+/**
+ * `otto_prepare_yield_deposit` — the constructor. See `yield-deposit-definition.ts` for WHY it is a swap.
+ *
+ * Order of operations, and what each step pins:
+ *   1. parse the strict input;
+ *   2. the registry row for `executableMarketId` (unknown → refused), the CURRENT commitment over the
+ *      complete record must equal the caller's (else refused: the READ half served a row this server
+ *      does not hold), and the row must be Base / USDC / MORPHO (anything else refused by name);
+ *   3. ONE LI.FI quote through `quoteSwap` for `USDC → row.vaultAddress` from the signing account —
+ *      `toToken` is the row's address, never the caller's;
+ *   4. deposit parity: the vault's own `previewDeposit(amount)` (read through the runtime's vault reader;
+ *      absent → refused, nothing prepared) versus the quoted shares, refused past the pinned tolerance;
+ *   5. the swap prepareInput with `slippage.minAmountOut` = the quote's floor, then the envelope from
+ *      THAT quote via `prepareSwapFromQuote` — so the pair is the one `otto_submit_under_delegation`
+ *      takes verbatim, the intent digest binds the floor, and no second quote can drift under it.
+ *
+ * Nothing here signs, submits, or touches the delegation; the cap applies at submit, to the approve amount.
+ */
+import { getHybridYieldMarket } from './hybrid-yield-markets.js';
+import { describeYieldRoute } from './yield-route-semantics.js';
+import { getAddress } from 'viem';
+import { getExecutableYieldMarket, getExecutableYieldMarketCommitment, } from './executable-yield-markets.js';
+import { refuse } from './execution-errors.js';
+import { PREPARE_SWAP_INPUT_SCHEMA } from './execution-tool-definitions.js';
+import { prepareSwapFromQuote, quoteSwap, } from './execution-tools.js';
+import { PREPARE_YIELD_DEPOSIT_INPUT_SCHEMA, PREPARE_YIELD_DEPOSIT_OUTPUT_SCHEMA, YIELD_DEPOSIT_PARITY_TOLERANCE_BPS, } from './yield-deposit-definition.js';
+/** Steps 2: the registry row, pinned to the caller's commitment and to Base / USDC / MORPHO. */
+export function resolveYieldDepositMarket(input) {
+    const market = getExecutableYieldMarket(input.executableMarketId);
+    if (!market) {
+        return refuse('YIELD_MARKET_UNKNOWN', `${input.executableMarketId} is not an executable yield market on this server`);
+    }
+    const current = getExecutableYieldMarketCommitment(market);
+    if (current !== input.registryCommitment) {
+        return refuse('YIELD_REGISTRY_MISMATCH', `the registry commitment presented for ${market.id} is not the current record's; re-read the market and prepare again`);
+    }
+    if (market.chainId !== 8453) {
+        return refuse('YIELD_MARKET_UNKNOWN', `${market.id} is not on Base mainnet (8453)`);
+    }
+    if (market.asset.symbol !== 'USDC') {
+        return refuse('YIELD_MARKET_UNKNOWN', `${market.id} is not a USDC market`);
+    }
+    if (market.protocol !== 'MORPHO') {
+        return refuse('YIELD_MARKET_UNKNOWN', `${market.id} is not an ERC-4626 Morpho vault; only Morpho markets deposit as a share-token route`);
+    }
+    return market;
+}
+/**
+ * Step 4, as a pure function: the shortfall of the quoted shares against the vault's own preview, in
+ * basis points of the preview (0 when the route quotes at or above the preview). Refuses past the
+ * pinned tolerance.
+ */
+export function assertDepositParity(previewShares, quotedShares) {
+    if (previewShares <= 0n) {
+        return refuse('YIELD_PREVIEW_UNAVAILABLE', 'the vault previews zero shares for this deposit');
+    }
+    if (quotedShares >= previewShares)
+        return 0;
+    const shortfallBps = Number(((previewShares - quotedShares) * 10000n) / previewShares);
+    // EXACT, by cross-multiplication (codex gate r1 LOW): the floored bps above is for the preview only; a
+    // shortfall of 30.99 bps floors to 30 and must still be refused.
+    if ((previewShares - quotedShares) * 10000n > previewShares * BigInt(YIELD_DEPOSIT_PARITY_TOLERANCE_BPS)) {
+        return refuse('YIELD_DEPOSIT_PARITY', `the route quotes ${shortfallBps} bps fewer shares than the vault's own previewDeposit (tolerance ${YIELD_DEPOSIT_PARITY_TOLERANCE_BPS} bps); the deposit is not prepared`);
+    }
+    return shortfallBps;
+}
+/** The fee lines LI.FI attached, as it names them — read for the preview; nothing is derived from them. */
+function quotedFeeLines(quote) {
+    const estimate = quote.estimate;
+    const lines = Array.isArray(estimate.feeCosts) ? estimate.feeCosts : [];
+    return lines.flatMap((line) => {
+        const l = line;
+        return typeof l.name === 'string' && typeof l.amountUSD === 'string'
+            ? [{ name: l.name, amount_usd: l.amountUSD }]
+            : [];
+    });
+}
+function quotedGasUsd(quote) {
+    const estimate = quote.estimate;
+    const first = Array.isArray(estimate.gasCosts) ? estimate.gasCosts[0] : undefined;
+    return typeof first?.amountUSD === 'string' ? first.amountUSD : undefined;
+}
+export async function prepareYieldDeposit(runtime, rawInput, signal) {
+    const input = PREPARE_YIELD_DEPOSIT_INPUT_SCHEMA.parse(rawInput);
+    const market = resolveYieldDepositMarket(input);
+    // Preparation-only curation gate. Shared identity resolution remains usable for
+    // withdrawal; existing signed/submitted artifacts keep their reconciliation path.
+    if (getHybridYieldMarket(market.id)?.curation.status === 'legacy-exit-only') {
+        return refuse('YIELD_DEPOSIT_UNAVAILABLE', 'This legacy vault is retained for withdrawals; choose a current market for a new deposit');
+    }
+    const reader = runtime.yieldVaultReader;
+    if (!reader) {
+        return refuse('YIELD_PREVIEW_UNAVAILABLE', 'this server has no vault reader, so deposit parity cannot be checked; nothing is prepared');
+    }
+    const vault = getAddress(market.vaultAddress);
+    const asset = getAddress(market.asset.address);
+    const amount = BigInt(input.amount);
+    // 3. The swap request, toToken PINNED to the registry vault. Quoted once.
+    const quoteInput = PREPARE_SWAP_INPUT_SCHEMA.parse({
+        accountProfile: input.accountProfile,
+        chainId: market.chainId,
+        fromToken: asset,
+        toToken: vault,
+        fromAmount: input.amount,
+        slippage: { maxBps: input.slippage.maxBps },
+        ...(input.client_ref ? { client_ref: input.client_ref } : {}),
+    });
+    const quote = await quoteSwap(runtime, quoteInput, signal);
+    const expectedShares = BigInt(quote.estimate.toAmount);
+    const minShares = BigInt(quote.estimate.toAmountMin);
+    // 4. Parity against the vault's own rate.
+    let previewShares;
+    try {
+        previewShares = await reader.previewDeposit(vault, amount);
+    }
+    catch {
+        return refuse('YIELD_PREVIEW_UNAVAILABLE', "the vault's previewDeposit could not be read, so deposit parity cannot be checked; nothing is prepared");
+    }
+    const shortfallBps = assertDepositParity(previewShares, expectedShares);
+    // 5. The pair: the floor goes INTO prepareInput before the envelope is built, so the intent digest binds it.
+    const prepareInput = PREPARE_SWAP_INPUT_SCHEMA.parse({
+        ...quoteInput,
+        slippage: { maxBps: input.slippage.maxBps, minAmountOut: minShares.toString() },
+    });
+    const envelope = prepareSwapFromQuote(runtime, prepareInput, quote);
+    return PREPARE_YIELD_DEPOSIT_OUTPUT_SCHEMA.parse({
+        envelope,
+        prepareInput,
+        preview: {
+            route_semantics: describeYieldRoute(quote, 'deposit', vault, market.chainId),
+            market_id: market.id,
+            venue: market.venue,
+            protocol: 'MORPHO',
+            chain_id: 8453,
+            vault,
+            asset,
+            amount: amount.toString(),
+            expected_shares: expectedShares.toString(),
+            min_shares: minShares.toString(),
+            preview_deposit_shares: previewShares.toString(),
+            parity_shortfall_bps: shortfallBps,
+            parity_tolerance_bps: YIELD_DEPOSIT_PARITY_TOLERANCE_BPS,
+            quoted_fees: quotedFeeLines(quote),
+            ...(quotedGasUsd(quote) !== undefined ? { quoted_gas_usd: quotedGasUsd(quote) } : {}),
+        },
+        registry_commitment: input.registryCommitment,
+    });
+}
+//# sourceMappingURL=yield-deposit.js.map

package/dist/yield-route-semantics.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Presentation evidence about a routed position trade. Provider step labels are
+ * declarations, not proof of protocol mint/burn. Settlement must establish that.
+ * This module never authorizes a target, spender, fee or destination call.
+ */
+import { z } from 'zod';
+import type { LiFiQuote } from './lifi-execution-client.js';
+export declare const YIELD_ROUTE_SEMANTICS_SCHEMA: z.ZodObject<{
+    transport: z.ZodLiteral<"lifi">;
+    action: z.ZodEnum<{
+        deposit: "deposit";
+        withdraw: "withdraw";
+    }>;
+    classification: z.ZodEnum<{
+        "share-purchase": "share-purchase";
+        "share-sale": "share-sale";
+        "protocol-composition": "protocol-composition";
+        mixed: "mixed";
+        unclassified: "unclassified";
+    }>;
+    evidence: z.ZodLiteral<"provider-quote-steps">;
+    protocol_action_verified: z.ZodLiteral<false>;
+    tools: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type YieldRouteSemantics = z.infer<typeof YIELD_ROUTE_SEMANTICS_SCHEMA>;
+/** Inspect terminal position-changing steps, bounded and matched to exact position token/chain. */
+export declare function describeYieldRoute(quote: LiFiQuote, action: 'deposit' | 'withdraw', positionToken: string, chainId: number): YieldRouteSemantics;

package/dist/yield-route-semantics.js

@@ -0,0 +1,71 @@
+/**
+ * Presentation evidence about a routed position trade. Provider step labels are
+ * declarations, not proof of protocol mint/burn. Settlement must establish that.
+ * This module never authorizes a target, spender, fee or destination call.
+ */
+import { z } from 'zod';
+export const YIELD_ROUTE_SEMANTICS_SCHEMA = z.object({
+    transport: z.literal('lifi'),
+    action: z.enum(['deposit', 'withdraw']),
+    classification: z.enum(['share-purchase', 'share-sale', 'protocol-composition', 'mixed', 'unclassified']),
+    evidence: z.literal('provider-quote-steps'),
+    protocol_action_verified: z.literal(false),
+    tools: z.array(z.string()),
+}).strict();
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value : null;
+}
+/** Inspect terminal position-changing steps, bounded and matched to exact position token/chain. */
+export function describeYieldRoute(quote, action, positionToken, chainId) {
+    const kinds = new Set();
+    const tools = new Set();
+    let unknown = false;
+    let count = 0;
+    const visit = (steps, depth) => {
+        if (!Array.isArray(steps) || depth > 4) {
+            unknown = true;
+            return;
+        }
+        for (const raw of steps) {
+            if (++count > 64) {
+                unknown = true;
+                return;
+            }
+            const step = object(raw);
+            if (!step) {
+                unknown = true;
+                continue;
+            }
+            if (step.type === 'fee')
+                continue;
+            if (Array.isArray(step.includedSteps) && step.includedSteps.length > 0) {
+                visit(step.includedSteps, depth + 1);
+                continue;
+            }
+            const a = object(step.action);
+            const token = object(action === 'deposit' ? a?.toToken : a?.fromToken);
+            const chain = action === 'deposit' ? a?.toChainId : a?.fromChainId;
+            if (typeof token?.address !== 'string' ||
+                token.address.toLowerCase() !== positionToken.toLowerCase() || chain !== chainId)
+                continue;
+            if (step.type !== 'swap' && step.type !== 'protocol') {
+                unknown = true;
+                continue;
+            }
+            kinds.add(step.type);
+            if (typeof step.tool === 'string' && /^[a-zA-Z0-9._-]{1,64}$/.test(step.tool))
+                tools.add(step.tool);
+        }
+    };
+    visit(quote.includedSteps, 0);
+    const classification = unknown || kinds.size === 0 ? 'unclassified'
+        : kinds.size > 1 ? 'mixed'
+            : kinds.has('protocol') ? 'protocol-composition'
+                : action === 'deposit' ? 'share-purchase' : 'share-sale';
+    return YIELD_ROUTE_SEMANTICS_SCHEMA.parse({
+        transport: 'lifi', action, classification, evidence: 'provider-quote-steps',
+        protocol_action_verified: false, tools: [...tools].sort(),
+    });
+}
+//# sourceMappingURL=yield-route-semantics.js.map

package/dist/yield-withdraw-definition.d.ts

@@ -0,0 +1,357 @@
+/**
+ * `otto_prepare_yield_withdraw` — the twin of `otto_prepare_yield_deposit` (Founder word `fence v2`,
+ * 2026-09-03): a delegated Yield Copilot WITHDRAW as a `otto_prepare_swap` pair whose INPUT token is the
+ * registry vault's share token and whose OUTPUT token is USDC, delivered to the signing account.
+ *
+ * WHY A SWAP. LI.FI routes `shares → USDC` through the diamond as a "composer" (zap-out) leg behind the same
+ * fenced GenericSwapV3 entry point, at redeem parity: on live quotes (2026-09-03) 0.5 gtUSDCp → 553,533 USDC
+ * units = the vault's own `previewRedeem` minus LI.FI's 0.25% fixed fee. The pair is submittable through
+ * the unchanged `otto_submit_under_delegation` path ONLY under fence v2 (the share-token approve rule) and
+ * ONLY for a permission minted under cap ruleset v2; the send gate values a withdraw at zero against the
+ * person's cap (it returns their own assets to them) and bounds it by the engine's share cap instead.
+ *
+ * WHAT THIS TOOL PINS: the input token is the registry row's `vaultAddress`, the output token is the row's
+ * asset (USDC), both never caller inputs; the row is the CURRENT registry record (commitment recomputed);
+ * REDEEM PARITY — the quoted USDC may not fall below the vault's own `previewRedeem(shares)` by more than
+ * `YIELD_WITHDRAW_PARITY_TOLERANCE_BPS`.
+ */
+import { z } from 'zod';
+import type { Address } from 'viem';
+export declare const YIELD_WITHDRAW_TOOL_NAME: "otto_prepare_yield_withdraw";
+/**
+ * 🔴 PINNED REDEEM-PARITY TOLERANCE, in bps of the vault's own `previewRedeem(shares)`. Same derivation as the
+ * deposit's: LI.FI's fixed fee-collection leg takes 0.25% of the INPUT (here: shares) before the zap-out
+ * (25 bps) + rounding headroom (5 bps) = 30 bps. `slippage.maxBps` bounds the on-chain floor, not this.
+ * A test pins this value; widening it must redden that test.
+ */
+export declare const YIELD_WITHDRAW_PARITY_TOLERANCE_BPS: 30;
+export declare const PREPARE_YIELD_WITHDRAW_INPUT_SCHEMA: z.ZodObject<{
+    accountProfile: z.ZodObject<{
+        kind: z.ZodEnum<{
+            eoa: "eoa";
+            safe: "safe";
+        }>;
+        address: z.ZodString;
+        chainId: z.ZodNumber;
+    }, z.core.$strict>;
+    executableMarketId: z.ZodString;
+    registryCommitment: z.ZodString;
+    shares: z.ZodString;
+    slippage: z.ZodObject<{
+        maxBps: z.ZodNumber;
+    }, z.core.$strict>;
+    client_ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PrepareYieldWithdrawInput = z.infer<typeof PREPARE_YIELD_WITHDRAW_INPUT_SCHEMA>;
+export declare const YIELD_WITHDRAW_PREVIEW_SCHEMA: z.ZodObject<{
+    market_id: z.ZodString;
+    venue: z.ZodString;
+    protocol: z.ZodLiteral<"MORPHO">;
+    chain_id: z.ZodLiteral<8453>;
+    vault: z.ZodString;
+    asset: z.ZodString;
+    shares: z.ZodString;
+    expected_assets: z.ZodString;
+    min_assets: z.ZodString;
+    preview_redeem_assets: z.ZodString;
+    parity_shortfall_bps: z.ZodNumber;
+    parity_tolerance_bps: z.ZodLiteral<30>;
+    quoted_fees: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        amount_usd: z.ZodString;
+    }, z.core.$strict>>;
+    quoted_gas_usd: z.ZodOptional<z.ZodString>;
+    route_semantics: z.ZodObject<{
+        transport: z.ZodLiteral<"lifi">;
+        action: z.ZodEnum<{
+            deposit: "deposit";
+            withdraw: "withdraw";
+        }>;
+        classification: z.ZodEnum<{
+            "share-purchase": "share-purchase";
+            "share-sale": "share-sale";
+            "protocol-composition": "protocol-composition";
+            mixed: "mixed";
+            unclassified: "unclassified";
+        }>;
+        evidence: z.ZodLiteral<"provider-quote-steps">;
+        protocol_action_verified: z.ZodLiteral<false>;
+        tools: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const PREPARE_YIELD_WITHDRAW_OUTPUT_SCHEMA: z.ZodObject<{
+    envelope: z.ZodObject<{
+        schema_version: z.ZodLiteral<"1">;
+        artifact_id: z.ZodString;
+        rail: z.ZodLiteral<"lifi">;
+        operation: z.ZodLiteral<"swap">;
+        intent_digest: z.ZodString;
+        account_binding: z.ZodObject<{
+            kind: z.ZodEnum<{
+                eoa: "eoa";
+                safe: "safe";
+            }>;
+            address: z.ZodString;
+            chainId: z.ZodNumber;
+            protocol_roles: z.ZodObject<{
+                lifi: z.ZodObject<{
+                    sender: z.ZodString;
+                    receiver: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        required_capabilities: z.ZodArray<z.ZodEnum<{
+            send_evm_transaction: "send_evm_transaction";
+            submit_evm_batch: "submit_evm_batch";
+        }>>;
+        payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"evm_execution_plan">;
+            chain_id: z.ZodNumber;
+            steps: z.ZodArray<z.ZodObject<{
+                to: z.ZodString;
+                value: z.ZodString;
+                data: z.ZodString;
+                kind: z.ZodEnum<{
+                    approve: "approve";
+                    approve_reset: "approve_reset";
+                    call: "call";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">;
+        fee_attribution: z.ZodObject<{
+            mechanism: z.ZodLiteral<"lifi_integrator_fee">;
+            config_version: z.ZodString;
+        }, z.core.$strict>;
+        replay_disclosure: z.ZodObject<{
+            artifact_role: z.ZodLiteral<"construction_aid">;
+            freshness_boundary: z.ZodLiteral<"valid_until">;
+            onchain_replay_boundary: z.ZodLiteral<"signer_account_nonce">;
+            tool_guarantees_single_execution: z.ZodLiteral<false>;
+        }, z.core.$strict>;
+        assertions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            result: z.ZodLiteral<"passed">;
+        }, z.core.$strict>>;
+        valid_until: z.ZodString;
+        submission: z.ZodObject<{
+            method: z.ZodEnum<{
+                send_evm_transaction: "send_evm_transaction";
+                submit_evm_batch: "submit_evm_batch";
+            }>;
+            chain_id: z.ZodNumber;
+            artifact_id: z.ZodString;
+            payload_digest: z.ZodString;
+            artifact_digest: z.ZodString;
+            adapter_owned_fields: z.ZodTuple<[z.ZodLiteral<"nonce">, z.ZodLiteral<"gas">, z.ZodLiteral<"serialization">], null>;
+            client_ref: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    prepareInput: z.ZodObject<{
+        accountProfile: z.ZodObject<{
+            kind: z.ZodEnum<{
+                eoa: "eoa";
+                safe: "safe";
+            }>;
+            address: z.ZodString;
+            chainId: z.ZodNumber;
+        }, z.core.$strict>;
+        chainId: z.ZodNumber;
+        fromToken: z.ZodString;
+        toToken: z.ZodString;
+        fromAmount: z.ZodString;
+        slippage: z.ZodObject<{
+            maxBps: z.ZodNumber;
+            minAmountOut: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        client_ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    preview: z.ZodObject<{
+        market_id: z.ZodString;
+        venue: z.ZodString;
+        protocol: z.ZodLiteral<"MORPHO">;
+        chain_id: z.ZodLiteral<8453>;
+        vault: z.ZodString;
+        asset: z.ZodString;
+        shares: z.ZodString;
+        expected_assets: z.ZodString;
+        min_assets: z.ZodString;
+        preview_redeem_assets: z.ZodString;
+        parity_shortfall_bps: z.ZodNumber;
+        parity_tolerance_bps: z.ZodLiteral<30>;
+        quoted_fees: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            amount_usd: z.ZodString;
+        }, z.core.$strict>>;
+        quoted_gas_usd: z.ZodOptional<z.ZodString>;
+        route_semantics: z.ZodObject<{
+            transport: z.ZodLiteral<"lifi">;
+            action: z.ZodEnum<{
+                deposit: "deposit";
+                withdraw: "withdraw";
+            }>;
+            classification: z.ZodEnum<{
+                "share-purchase": "share-purchase";
+                "share-sale": "share-sale";
+                "protocol-composition": "protocol-composition";
+                mixed: "mixed";
+                unclassified: "unclassified";
+            }>;
+            evidence: z.ZodLiteral<"provider-quote-steps">;
+            protocol_action_verified: z.ZodLiteral<false>;
+            tools: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    registry_commitment: z.ZodString;
+}, z.core.$strict>;
+export type PrepareYieldWithdrawOutput = z.infer<typeof PREPARE_YIELD_WITHDRAW_OUTPUT_SCHEMA>;
+/** The vault reads both yield constructors need; production runs them over the delegation rig's public client. */
+export interface YieldVaultReader {
+    previewDeposit(vault: Address, assets: bigint): Promise<bigint>;
+    previewRedeem(vault: Address, shares: bigint): Promise<bigint>;
+}
+export declare const YIELD_WITHDRAW_TOOL_DEFINITION: Readonly<{
+    name: "otto_prepare_yield_withdraw";
+    title: "Prepare a Yield Copilot vault withdraw (Morpho USDC on Base) as a delegable swap pair";
+    description: "Prepare the EXACT otto_prepare_swap pair (envelope + prepareInput) that redeems vault shares from one of the executable Morpho vaults in the Yield Copilot registry back to USDC in the signing account, as a LI.FI exit route (which may sell shares or compose a protocol redemption) whose input token is the vault's ERC-4626 share token. The vault and the asset come from the registry row named by executableMarketId and are never inputs; the caller's registryCommitment must equal the commitment recomputed over the current record. The quoted USDC is checked against the vault's own previewRedeem and refused when it falls short by more than the pinned tolerance. Returns the pair unchanged plus a preview; never signs or submits — submit the pair through otto_submit_under_delegation, which admits a withdraw only under fence v2 and a permission minted under cap ruleset v2, values it at zero against the per-swap cap (it returns the person's own assets), and bounds it by the engine's share cap.";
+    inputSchema: z.ZodObject<{
+        accountProfile: z.ZodObject<{
+            kind: z.ZodEnum<{
+                eoa: "eoa";
+                safe: "safe";
+            }>;
+            address: z.ZodString;
+            chainId: z.ZodNumber;
+        }, z.core.$strict>;
+        executableMarketId: z.ZodString;
+        registryCommitment: z.ZodString;
+        shares: z.ZodString;
+        slippage: z.ZodObject<{
+            maxBps: z.ZodNumber;
+        }, z.core.$strict>;
+        client_ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    outputSchema: z.ZodObject<{
+        envelope: z.ZodObject<{
+            schema_version: z.ZodLiteral<"1">;
+            artifact_id: z.ZodString;
+            rail: z.ZodLiteral<"lifi">;
+            operation: z.ZodLiteral<"swap">;
+            intent_digest: z.ZodString;
+            account_binding: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    eoa: "eoa";
+                    safe: "safe";
+                }>;
+                address: z.ZodString;
+                chainId: z.ZodNumber;
+                protocol_roles: z.ZodObject<{
+                    lifi: z.ZodObject<{
+                        sender: z.ZodString;
+                        receiver: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            required_capabilities: z.ZodArray<z.ZodEnum<{
+                send_evm_transaction: "send_evm_transaction";
+                submit_evm_batch: "submit_evm_batch";
+            }>>;
+            payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"evm_execution_plan">;
+                chain_id: z.ZodNumber;
+                steps: z.ZodArray<z.ZodObject<{
+                    to: z.ZodString;
+                    value: z.ZodString;
+                    data: z.ZodString;
+                    kind: z.ZodEnum<{
+                        approve: "approve";
+                        approve_reset: "approve_reset";
+                        call: "call";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>], "kind">;
+            fee_attribution: z.ZodObject<{
+                mechanism: z.ZodLiteral<"lifi_integrator_fee">;
+                config_version: z.ZodString;
+            }, z.core.$strict>;
+            replay_disclosure: z.ZodObject<{
+                artifact_role: z.ZodLiteral<"construction_aid">;
+                freshness_boundary: z.ZodLiteral<"valid_until">;
+                onchain_replay_boundary: z.ZodLiteral<"signer_account_nonce">;
+                tool_guarantees_single_execution: z.ZodLiteral<false>;
+            }, z.core.$strict>;
+            assertions: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                result: z.ZodLiteral<"passed">;
+            }, z.core.$strict>>;
+            valid_until: z.ZodString;
+            submission: z.ZodObject<{
+                method: z.ZodEnum<{
+                    send_evm_transaction: "send_evm_transaction";
+                    submit_evm_batch: "submit_evm_batch";
+                }>;
+                chain_id: z.ZodNumber;
+                artifact_id: z.ZodString;
+                payload_digest: z.ZodString;
+                artifact_digest: z.ZodString;
+                adapter_owned_fields: z.ZodTuple<[z.ZodLiteral<"nonce">, z.ZodLiteral<"gas">, z.ZodLiteral<"serialization">], null>;
+                client_ref: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        prepareInput: z.ZodObject<{
+            accountProfile: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    eoa: "eoa";
+                    safe: "safe";
+                }>;
+                address: z.ZodString;
+                chainId: z.ZodNumber;
+            }, z.core.$strict>;
+            chainId: z.ZodNumber;
+            fromToken: z.ZodString;
+            toToken: z.ZodString;
+            fromAmount: z.ZodString;
+            slippage: z.ZodObject<{
+                maxBps: z.ZodNumber;
+                minAmountOut: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            client_ref: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        preview: z.ZodObject<{
+            market_id: z.ZodString;
+            venue: z.ZodString;
+            protocol: z.ZodLiteral<"MORPHO">;
+            chain_id: z.ZodLiteral<8453>;
+            vault: z.ZodString;
+            asset: z.ZodString;
+            shares: z.ZodString;
+            expected_assets: z.ZodString;
+            min_assets: z.ZodString;
+            preview_redeem_assets: z.ZodString;
+            parity_shortfall_bps: z.ZodNumber;
+            parity_tolerance_bps: z.ZodLiteral<30>;
+            quoted_fees: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                amount_usd: z.ZodString;
+            }, z.core.$strict>>;
+            quoted_gas_usd: z.ZodOptional<z.ZodString>;
+            route_semantics: z.ZodObject<{
+                transport: z.ZodLiteral<"lifi">;
+                action: z.ZodEnum<{
+                    deposit: "deposit";
+                    withdraw: "withdraw";
+                }>;
+                classification: z.ZodEnum<{
+                    "share-purchase": "share-purchase";
+                    "share-sale": "share-sale";
+                    "protocol-composition": "protocol-composition";
+                    mixed: "mixed";
+                    unclassified: "unclassified";
+                }>;
+                evidence: z.ZodLiteral<"provider-quote-steps">;
+                protocol_action_verified: z.ZodLiteral<false>;
+                tools: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        registry_commitment: z.ZodString;
+    }, z.core.$strict>;
+}>;