otto-intel-mcp 0.1.2 → 0.1.4

package/dist/vendor/lp-v3/v4-math.js

@@ -0,0 +1,90 @@
+import { encodeAbiParameters, keccak256 } from 'viem';
+export const Q96 = 1n << 96n;
+export const Q128 = 1n << 128n;
+export const UINT256_MOD = 1n << 256n;
+export const MIN_TICK = -887272;
+export const MAX_TICK = 887272;
+function uint(value, bits) {
+    if (value < 0n || value >= (1n << BigInt(bits)))
+        throw new Error(`Invalid uint${bits}`);
+}
+// The mathematical constants and rounding follow Uniswap's MIT-licensed TickMath:
+// https://github.com/Uniswap/v4-core/blob/main/src/libraries/TickMath.sol
+const TICK_FACTORS = [
+    0xfffcb933bd6fad37aa2d162d1a594001n, 0xfff97272373d413259a46990580e213an,
+    0xfff2e50f5f656932ef12357cf3c7fdccn, 0xffe5caca7e10e4e61c3624eaa0941cd0n,
+    0xffcb9843d60f6159c9db58835c926644n, 0xff973b41fa98c081472e6896dfb254c0n,
+    0xff2ea16466c96a3843ec78b326b52861n, 0xfe5dee046a99a2a811c461f1969c3053n,
+    0xfcbe86c7900a88aedcffc83b479aa3a4n, 0xf987a7253ac413176f2b074cf7815e54n,
+    0xf3392b0822b70005940c7a398e4b70f3n, 0xe7159475a2c29b7443b29c7fa6e889d9n,
+    0xd097f3bdfd2022b8845ad8f792aa5825n, 0xa9f746462d870fdf8a65dc1f90e061e5n,
+    0x70d869a156d2a1b890bb3df62baf32f7n, 0x31be135f97d08fd981231505542fcfa6n,
+    0x9aa508b5b7a84e1c677de54f3e99bc9n, 0x5d6af8dedb81196699c329225ee604n,
+    0x2216e584f5fa1ea926041bedfe98n, 0x48a170391f7dc42444e8fa2n,
+];
+export function sqrtPriceAtTick(tick) {
+    if (!Number.isInteger(tick) || tick < MIN_TICK || tick > MAX_TICK)
+        throw new Error('Invalid tick');
+    const magnitude = Math.abs(tick);
+    let ratio = Q128;
+    for (let bit = 0; bit < TICK_FACTORS.length; bit++) {
+        if ((magnitude & (1 << bit)) !== 0)
+            ratio = (ratio * TICK_FACTORS[bit]) >> 128n;
+    }
+    if (tick > 0)
+        ratio = (UINT256_MOD - 1n) / ratio;
+    return (ratio + (1n << 32n) - 1n) >> 32n;
+}
+// PositionInfo has lower tick at bit 8, upper tick at bit 32, and the
+// most-significant 200 bits of the pool hash at bit 56 (not the low 200 bits).
+// https://github.com/Uniswap/v4-periphery/blob/main/src/libraries/PositionInfoLibrary.sol
+export function unpackPositionInfo(info) {
+    uint(info, 256);
+    const signed24 = (n) => Number(BigInt.asIntN(24, n));
+    return {
+        lowerTick: signed24(info >> 8n), upperTick: signed24(info >> 32n),
+        poolIdPrefix: `0x${(info >> 56n).toString(16).padStart(50, '0')}`,
+        hasSubscriber: (info & 255n) !== 0n,
+    };
+}
+export function poolId(key) {
+    return keccak256(encodeAbiParameters([
+        { type: 'address' }, { type: 'address' }, { type: 'uint24' },
+        { type: 'int24' }, { type: 'address' },
+    ], [key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks]));
+}
+export function feesOwed(liquidity, current, checkpoint) {
+    uint(liquidity, 128);
+    return current.map((growth, i) => {
+        uint(growth, 256);
+        uint(checkpoint[i], 256);
+        // Core intentionally permits uint256 fee-growth subtraction to wrap.
+        const delta = (growth - checkpoint[i] + UINT256_MOD) % UINT256_MOD;
+        const owed = delta * liquidity / Q128;
+        uint(owed, 256);
+        return owed;
+    });
+}
+export function principalAmounts(liquidity, sqrtPriceX96, lowerTick, upperTick) {
+    uint(liquidity, 128);
+    uint(sqrtPriceX96, 160);
+    if (sqrtPriceX96 === 0n || lowerTick >= upperTick)
+        throw new Error('Invalid position range or price');
+    const lower = sqrtPriceAtTick(lowerTick), upper = sqrtPriceAtTick(upperTick);
+    const clamped = sqrtPriceX96 < lower ? lower : sqrtPriceX96 > upper ? upper : sqrtPriceX96;
+    // Rounded down, matching principal returned by removing this liquidity.
+    return [liquidity * Q96 * (upper - clamped) / upper / clamped,
+        liquidity * (clamped - lower) / Q96];
+}
+/** Human units of currency1 per one currency0. Display marks only, never raw accounting. */
+export function humanPriceRatio(sqrtPriceX96, decimals0, decimals1) {
+    uint(sqrtPriceX96, 160);
+    for (const d of [decimals0, decimals1])
+        if (!Number.isInteger(d) || d < 0 || d > 36)
+            throw new Error('Unsupported decimals');
+    const result = (Number(sqrtPriceX96) / Number(Q96)) ** 2 * 10 ** (decimals0 - decimals1);
+    if (!Number.isFinite(result) || result <= 0)
+        throw new Error('Invalid mark ratio');
+    return result;
+}
+//# sourceMappingURL=v4-math.js.map

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

@@ -0,0 +1,374 @@
+/**
+ * `otto_prepare_yield_deposit` — the Yield Copilot EXECUTION half at BARE (Founder word `yield deploy`,
+ * 2026-09-03), as a thin constructor over `otto_prepare_swap`.
+ *
+ * WHY A SWAP. The Morpho MetaMorpho vaults in the executable-yield registry are ERC-4626, and LI.FI quotes
+ * USDC → the vault's SHARE token as a same-chain route through the LI.FI diamond whose calldata is one of
+ * the two fenced GenericSwapV3 entry points, with the shares delivered to the payer's own address. The
+ * share-token output does not establish a protocol mint: LI.FI may instead buy shares on a
+ * secondary market. Parity bounds quoted economics; it cannot prove the protocol action.
+ * So the deposit IS a `otto_prepare_swap` pair with `toToken` pinned to the registry vault — inside the
+ * v1 delegation fence (approve to the diamond on an allow-listed input token; call = the fenced selector;
+ * receiver == the signing account), submittable through the unchanged `otto_submit_under_delegation` path
+ * under the per-swap cap (the cap's gross is the approve amount, i.e. the USDC deposited). Nothing about
+ * the fence, the cap store or the send gate changes.
+ *
+ * WHAT THIS TOOL PINS THAT A RAW SWAP DOES NOT:
+ *   - the OUTPUT token is the registry row's `vaultAddress`, never a caller input;
+ *   - the row is the CURRENT registry record: the caller's `registryCommitment` (what the READ half served)
+ *     must equal the commitment recomputed here over the complete record, else refused by name;
+ *   - chain 8453 / asset USDC / protocol MORPHO, from the row, refused otherwise;
+ *   - DEPOSIT PARITY: the quoted shares may not fall below the vault's own `previewDeposit(amount)` by
+ *     more than `YIELD_DEPOSIT_PARITY_TOLERANCE_BPS` — so a thin secondary pool can never silently
+ *     produce a materially worse acquisition quote. This does not prove a mint.
+ * The receiver is the signing account by construction (the swap verifier binds `_receiver` to it and the
+ * delegated send binds the account to the end user's CDP accounts), so it is not an input anywhere.
+ *
+ * The WITHDRAW is the twin constructor `otto_prepare_yield_withdraw` (shares → USDC through the same fenced
+ * entry), admitted by the send gate only under fence v2 (Founder word `fence v2`, 2026-09-03): the Model-B
+ * fence is default-deny for every end-user-signed send in the project, so a user-signed `vault.redeem` is
+ * not a path out (ws-7 probe, 2026-09-03), and a deposit-only surface would trap the person's USDC.
+ */
+import { z } from 'zod';
+export declare const YIELD_DEPOSIT_TOOL_NAME: "otto_prepare_yield_deposit";
+/**
+ * 🔴 PINNED DEPOSIT-PARITY TOLERANCE, in basis points of the vault's own `previewDeposit(amount)`.
+ *
+ * Derivation (live li.quest quotes, 2026-09-03, production params `integrator=ottowallet&fee=0.001`):
+ *   - LI.FI's fee-collection leg takes a FIXED 0.25% of the input before the vault leg
+ *     (`feeCosts: LIFI Fixed Fee 0.0025`; `fromAmount` 1,000,000 → swap leg 997,500)  → 25 bps
+ *   - the aggregator's mint of the post-fee amount matched `previewDeposit` to 6 s.f.; one share-unit
+ *     of ERC-4626 rounding on an 18-decimal share is far below 1 bps                 → 5 bps headroom
+ *   = 30 bps. `slippage.maxBps` is NOT part of this number: it bounds the on-chain floor
+ *   (`minAmountOut`, enforced by the router), while this tolerance bounds the QUOTE itself — a route that
+ *   quotes worse than the vault's own rate is refused before anything is prepared, whatever the floor.
+ * A test pins this value; widening it must redden that test.
+ */
+export declare const YIELD_DEPOSIT_PARITY_TOLERANCE_BPS: 30;
+export declare const PREPARE_YIELD_DEPOSIT_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;
+    amount: z.ZodString;
+    slippage: z.ZodObject<{
+        maxBps: z.ZodNumber;
+    }, z.core.$strict>;
+    client_ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PrepareYieldDepositInput = z.infer<typeof PREPARE_YIELD_DEPOSIT_INPUT_SCHEMA>;
+export declare const YIELD_DEPOSIT_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;
+    amount: z.ZodString;
+    expected_shares: z.ZodString;
+    min_shares: z.ZodString;
+    preview_deposit_shares: 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_DEPOSIT_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;
+        amount: z.ZodString;
+        expected_shares: z.ZodString;
+        min_shares: z.ZodString;
+        preview_deposit_shares: 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 PrepareYieldDepositOutput = z.infer<typeof PREPARE_YIELD_DEPOSIT_OUTPUT_SCHEMA>;
+/** The vault reads both yield constructors need — declared once, with the withdraw twin. */
+export type { YieldVaultReader } from './yield-withdraw-definition.js';
+export declare const YIELD_DEPOSIT_TOOL_DEFINITION: Readonly<{
+    name: "otto_prepare_yield_deposit";
+    title: "Prepare a Yield Copilot vault deposit (Morpho USDC on Base) as a delegable swap pair";
+    description: "Prepare the EXACT otto_prepare_swap pair (envelope + prepareInput) that deposits USDC into one of the executable Morpho vaults from the Yield Copilot registry, as a LI.FI position-acquisition route (which may buy shares or compose a protocol deposit) whose output token is the vault's ERC-4626 share token and whose receiver is the signing account. The vault comes from the registry row named by executableMarketId and is never an input; the caller's registryCommitment must equal the commitment recomputed over the current record. The quoted shares are checked against the vault's own previewDeposit and refused when they fall 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 under the end user's per-swap 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;
+        amount: 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;
+            amount: z.ZodString;
+            expected_shares: z.ZodString;
+            min_shares: z.ZodString;
+            preview_deposit_shares: 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>;
+}>;

package/dist/yield-deposit-definition.js

@@ -0,0 +1,123 @@
+/**
+ * `otto_prepare_yield_deposit` — the Yield Copilot EXECUTION half at BARE (Founder word `yield deploy`,
+ * 2026-09-03), as a thin constructor over `otto_prepare_swap`.
+ *
+ * WHY A SWAP. The Morpho MetaMorpho vaults in the executable-yield registry are ERC-4626, and LI.FI quotes
+ * USDC → the vault's SHARE token as a same-chain route through the LI.FI diamond whose calldata is one of
+ * the two fenced GenericSwapV3 entry points, with the shares delivered to the payer's own address. The
+ * share-token output does not establish a protocol mint: LI.FI may instead buy shares on a
+ * secondary market. Parity bounds quoted economics; it cannot prove the protocol action.
+ * So the deposit IS a `otto_prepare_swap` pair with `toToken` pinned to the registry vault — inside the
+ * v1 delegation fence (approve to the diamond on an allow-listed input token; call = the fenced selector;
+ * receiver == the signing account), submittable through the unchanged `otto_submit_under_delegation` path
+ * under the per-swap cap (the cap's gross is the approve amount, i.e. the USDC deposited). Nothing about
+ * the fence, the cap store or the send gate changes.
+ *
+ * WHAT THIS TOOL PINS THAT A RAW SWAP DOES NOT:
+ *   - the OUTPUT token is the registry row's `vaultAddress`, never a caller input;
+ *   - the row is the CURRENT registry record: the caller's `registryCommitment` (what the READ half served)
+ *     must equal the commitment recomputed here over the complete record, else refused by name;
+ *   - chain 8453 / asset USDC / protocol MORPHO, from the row, refused otherwise;
+ *   - DEPOSIT PARITY: the quoted shares may not fall below the vault's own `previewDeposit(amount)` by
+ *     more than `YIELD_DEPOSIT_PARITY_TOLERANCE_BPS` — so a thin secondary pool can never silently
+ *     produce a materially worse acquisition quote. This does not prove a mint.
+ * The receiver is the signing account by construction (the swap verifier binds `_receiver` to it and the
+ * delegated send binds the account to the end user's CDP accounts), so it is not an input anywhere.
+ *
+ * The WITHDRAW is the twin constructor `otto_prepare_yield_withdraw` (shares → USDC through the same fenced
+ * entry), admitted by the send gate only under fence v2 (Founder word `fence v2`, 2026-09-03): the Model-B
+ * fence is default-deny for every end-user-signed send in the project, so a user-signed `vault.redeem` is
+ * not a path out (ws-7 probe, 2026-09-03), and a deposit-only surface would trap the person's USDC.
+ */
+import { z } from 'zod';
+import { YIELD_ROUTE_SEMANTICS_SCHEMA } from './yield-route-semantics.js';
+import { ACCOUNT_PROFILE_SCHEMA, EXECUTION_ENVELOPE_SCHEMA, PREPARE_SWAP_INPUT_SCHEMA, } from './execution-tool-definitions.js';
+export const YIELD_DEPOSIT_TOOL_NAME = 'otto_prepare_yield_deposit';
+/**
+ * 🔴 PINNED DEPOSIT-PARITY TOLERANCE, in basis points of the vault's own `previewDeposit(amount)`.
+ *
+ * Derivation (live li.quest quotes, 2026-09-03, production params `integrator=ottowallet&fee=0.001`):
+ *   - LI.FI's fee-collection leg takes a FIXED 0.25% of the input before the vault leg
+ *     (`feeCosts: LIFI Fixed Fee 0.0025`; `fromAmount` 1,000,000 → swap leg 997,500)  → 25 bps
+ *   - the aggregator's mint of the post-fee amount matched `previewDeposit` to 6 s.f.; one share-unit
+ *     of ERC-4626 rounding on an 18-decimal share is far below 1 bps                 → 5 bps headroom
+ *   = 30 bps. `slippage.maxBps` is NOT part of this number: it bounds the on-chain floor
+ *   (`minAmountOut`, enforced by the router), while this tolerance bounds the QUOTE itself — a route that
+ *   quotes worse than the vault's own rate is refused before anything is prepared, whatever the floor.
+ * A test pins this value; widening it must redden that test.
+ */
+export const YIELD_DEPOSIT_PARITY_TOLERANCE_BPS = 30;
+const uintString = z
+    .string()
+    .regex(/^[1-9]\d*$/, 'must be a positive decimal integer')
+    .refine((value) => BigInt(value) <= (1n << 256n) - 1n, 'must fit uint256');
+export const PREPARE_YIELD_DEPOSIT_INPUT_SCHEMA = z
+    .object({
+    accountProfile: ACCOUNT_PROFILE_SCHEMA,
+    executableMarketId: z
+        .string()
+        .min(1)
+        .max(120)
+        .describe('The executable market id the READ half served (`GET /api/yield-copilot` rows with deployable:true), e.g. base-usdc-morpho-gauntlet-prime.'),
+    registryCommitment: z
+        .string()
+        .regex(/^sha256:[0-9a-f]{64}$/, 'must be the sha256:… registry commitment the READ half served')
+        .describe("The registry commitment served with that row. It must equal the commitment this server recomputes over the CURRENT record; a stale or foreign row is refused by name."),
+    amount: uintString.describe('Exact USDC amount to deposit, in atomic units (6 decimals).'),
+    slippage: z
+        .object({
+        maxBps: z.number().int().min(1).max(1_000),
+    })
+        .strict(),
+    client_ref: z.string().trim().min(1).max(128).optional(),
+})
+    .strict();
+const addressOut = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
+const uintOut = z.string().regex(/^\d+$/);
+export const YIELD_DEPOSIT_PREVIEW_SCHEMA = z
+    .object({
+    market_id: z.string(),
+    venue: z.string(),
+    protocol: z.literal('MORPHO'),
+    chain_id: z.literal(8453),
+    vault: addressOut,
+    asset: addressOut,
+    /** The USDC deposited (atomic) — the cap's gross at submit is this same approve amount. */
+    amount: uintOut,
+    /** Shares the route quotes for `amount` (18-decimal vault shares). */
+    expected_shares: uintOut,
+    /** The on-chain floor the router enforces; what `prepareInput.slippage.minAmountOut` carries. */
+    min_shares: uintOut,
+    /** The vault's own `previewDeposit(amount)` at prepare time. */
+    preview_deposit_shares: uintOut,
+    /** `preview_deposit_shares − expected_shares`, in bps of the preview; ≤ the pinned tolerance. */
+    parity_shortfall_bps: z.number().int().min(0),
+    parity_tolerance_bps: z.literal(YIELD_DEPOSIT_PARITY_TOLERANCE_BPS),
+    /** The fee lines the router attached to the quote, as LI.FI names them (amount in USD). */
+    quoted_fees: z.array(z.object({ name: z.string(), amount_usd: z.string() }).strict()),
+    /** The route's own gas estimate for the call step, in USD, when LI.FI reported one. */
+    quoted_gas_usd: z.string().optional(),
+    route_semantics: YIELD_ROUTE_SEMANTICS_SCHEMA,
+})
+    .strict();
+export const PREPARE_YIELD_DEPOSIT_OUTPUT_SCHEMA = z
+    .object({
+    /** The EXACT `otto_prepare_swap` envelope — submit it unchanged. */
+    envelope: EXECUTION_ENVELOPE_SCHEMA,
+    /**
+     * The EXACT `otto_prepare_swap` request that produced the envelope, with `slippage.minAmountOut` FILLED
+     * from the quote's floor — the pair `otto_submit_under_delegation` takes, verbatim.
+     */
+    prepareInput: PREPARE_SWAP_INPUT_SCHEMA,
+    preview: YIELD_DEPOSIT_PREVIEW_SCHEMA,
+    registry_commitment: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+})
+    .strict();
+export const YIELD_DEPOSIT_TOOL_DEFINITION = Object.freeze({
+    name: YIELD_DEPOSIT_TOOL_NAME,
+    title: 'Prepare a Yield Copilot vault deposit (Morpho USDC on Base) as a delegable swap pair',
+    description: "Prepare the EXACT otto_prepare_swap pair (envelope + prepareInput) that deposits USDC into one of the executable Morpho vaults from the Yield Copilot registry, as a LI.FI position-acquisition route (which may buy shares or compose a protocol deposit) whose output token is the vault's ERC-4626 share token and whose receiver is the signing account. The vault comes from the registry row named by executableMarketId and is never an input; the caller's registryCommitment must equal the commitment recomputed over the current record. The quoted shares are checked against the vault's own previewDeposit and refused when they fall 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 under the end user's per-swap cap.",
+    inputSchema: PREPARE_YIELD_DEPOSIT_INPUT_SCHEMA,
+    outputSchema: PREPARE_YIELD_DEPOSIT_OUTPUT_SCHEMA,
+});
+//# sourceMappingURL=yield-deposit-definition.js.map

package/dist/yield-deposit.d.ts

@@ -0,0 +1,16 @@
+import { type ExecutableYieldMarket } from './executable-yield-markets.js';
+import { type ExecutionToolRuntime } from './execution-tools.js';
+import { type PrepareYieldDepositInput, type PrepareYieldDepositOutput } from './yield-deposit-definition.js';
+type MorphoMarket = Extract<ExecutableYieldMarket, {
+    readonly protocol: 'MORPHO';
+}>;
+/** Steps 2: the registry row, pinned to the caller's commitment and to Base / USDC / MORPHO. */
+export declare function resolveYieldDepositMarket(input: Pick<PrepareYieldDepositInput, 'executableMarketId' | 'registryCommitment'>): MorphoMarket;
+/**
+ * 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 declare function assertDepositParity(previewShares: bigint, quotedShares: bigint): number;
+export declare function prepareYieldDeposit(runtime: ExecutionToolRuntime, rawInput: unknown, signal?: AbortSignal): Promise<PrepareYieldDepositOutput>;
+export {};