otto-intel-mcp 0.1.2 → 0.1.4

package/dist/execution-tools.js

@@ -1,9 +1,13 @@
+import { createHostedLpUserOpBinding } from './lp-userop-hosted.js';
+import { createHostedNativeYieldUserOpBinding } from './native-yield-userop-hosted.js';
+import { createHostedSponsoredAccountBinding } from './execution-sponsored-hosted.js';
 import { randomBytes } from 'node:crypto';
 import { encodeFunctionData, getAddress, parseAbi } from 'viem';
 import { attributedFeeAmount, HL_BUILDER_ATTRIBUTION_STATUS, HYPERLIQUID_L1_SIGNATURE_CHAIN_ID, isEnumeratedCctpBridgeRoute, reviewedLiFiFeeForwarders, loadExecutionServiceConfig, POLYMARKET_CHAIN_ID, } from './execution-config.js';
 import { refuse } from './execution-errors.js';
 import { createDelegationServicesFromEnv, } from './execution-delegation.js';
 import { recordPreparedArtifact } from './prepared-artifacts.js';
+import { createRouteSimulator } from './adapter/route-simulator.js';
 import { swapIntentDigestInput } from './execution-intent.js';
 import { BRIDGE_EXECUTION_ENVELOPE_SCHEMA, EXECUTION_ENVELOPE_SCHEMA, HYPERLIQUID_EXECUTION_ENVELOPE_SCHEMA, POLYMARKET_EXECUTION_ENVELOPE_SCHEMA, PREPARE_BRIDGE_INPUT_SCHEMA, PREPARE_PERP_ORDER_INPUT_SCHEMA, PREPARE_POLYMARKET_ORDER_INPUT_SCHEMA, PREPARE_SWAP_INPUT_SCHEMA, } from './execution-tool-definitions.js';
 import { accountBinding, artifactCommitmentDigest, bridgeAccountBinding, createArtifactId, executionDigest, hyperliquidAccountBinding, polymarketAccountBinding, } from './execution-types.js';
@@ -11,8 +15,12 @@ import { RestHyperliquidInfoClient, } from './hyperliquid-info-client.js';
 import { assertHyperliquidBracketCoherent, assertHyperliquidPriceOnGrid, assertHyperliquidSizeOnGrid, decodeAndAssertHyperliquidAction, hyperliquidSigningDeclaration, } from './hyperliquid-order-assertions.js';
 import { buildUnsignedHyperliquidOrderAction, } from './hyperliquid-order-builder.js';
 import { decodeAndAssertLiFiBridge } from './lifi-bridge-assertions.js';
-import { RestLiFiQuoteClient } from './lifi-execution-client.js';
+import { RestLiFiQuoteClient, } from './lifi-execution-client.js';
 import { decodeAndAssertLiFiSwap } from './lifi-swap-assertions.js';
+import { modelBWithdrawToken } from './execution-delegation-policy.js';
+import { viemYieldVaultReader } from './yield-withdraw.js';
+import { viemEquityOracleReader } from './stock-buy-oracle.js';
+import { EXECUTABLE_EQUITY_TOKEN_SET } from './executable-equities.js';
 import { RestPolymarketClobClient } from './polymarket-clob-client.js';
 import { assertPolymarketBuilderAttributionRuled, assertPolymarketPriceOnTick, decodeAndAssertPolymarketOrder, polymarketAtomicUnits, } from './polymarket-order-assertions.js';
 import { buildUnsignedPolymarketOrder, } from './polymarket-order-builder.js';
@@ -31,6 +39,12 @@ export function createExecutionToolRuntime(config, overrides = {}) {
         entropy: overrides.entropy ?? (() => randomBytes(10)),
         clientOrderIdEntropy: overrides.clientOrderIdEntropy ?? (() => randomBytes(16)),
         ...(overrides.delegation ? { delegation: overrides.delegation } : {}),
+        ...(overrides.sponsoredAccount ? { sponsoredAccount: overrides.sponsoredAccount } : {}),
+        ...(overrides.nativeYieldUserOp ? { nativeYieldUserOp: overrides.nativeYieldUserOp } : {}),
+        ...(overrides.lpUserOp ? { lpUserOp: overrides.lpUserOp } : {}),
+        ...(overrides.routeSimulator ? { routeSimulator: overrides.routeSimulator } : {}),
+        ...(overrides.yieldVaultReader ? { yieldVaultReader: overrides.yieldVaultReader } : {}),
+        ...(overrides.equityOracleReader ? { equityOracleReader: overrides.equityOracleReader } : {}),
     });
 }
 export function createExecutionToolRuntimeFromEnv(env = process.env) {
@@ -52,8 +66,24 @@ export async function createExecutionToolRuntimeWithDelegationFromEnv(env = proc
         }
         return undefined;
     }
-    return createExecutionToolRuntime(config, delegation ? { delegation } : {});
+    // The delegated rail's Base client doubles as the route simulator's view of the chain (#2125) and as
+    // the yield constructor's vault read and the stock constructor's Chainlink read (#2129).
+    return createExecutionToolRuntime(config, {
+        ...(delegation
+            ? {
+                delegation,
+                sponsoredAccount: await createHostedSponsoredAccountBinding(env, delegation),
+                nativeYieldUserOp: await createHostedNativeYieldUserOpBinding(env, delegation),
+                lpUserOp: await createHostedLpUserOpBinding(env, delegation),
+                yieldVaultReader: viemYieldVaultReader(delegation.rig.rig.pub),
+                equityOracleReader: viemEquityOracleReader(delegation.rig.rig.pub),
+            }
+            : {}),
+        ...(delegation?.pub ? { routeSimulator: createRouteSimulator(delegation.pub) } : {}),
+    });
 }
+/** How many LI.FI tools the constructor will try before it refuses: the first quote plus two re-quotes. */
+export const MAX_ROUTE_ATTEMPTS = 3;
 function normalizedAddress(value) {
     return getAddress(value.toLowerCase());
 }
@@ -135,6 +165,29 @@ function capabilityFor(profile) {
 }
 export async function prepareSwap(runtime, rawInput, signal) {
     const input = PREPARE_SWAP_INPUT_SCHEMA.parse(rawInput);
+    /**
+     * 🔴 REGISTRY VAULT SHARES ARE EXCLUSIVE TO THE YIELD CONSTRUCTORS (codex gate r1 HIGH 2). A generic swap
+     * whose input or output is a Yield Copilot vault share would reach the delegated gate as an
+     * indistinguishable `operation: 'swap'` artifact and be admitted as a deposit/withdraw WITHOUT the registry
+     * commitment and the vault-parity guard the yield constructors run. So this public constructor refuses that
+     * token class by name; `otto_prepare_yield_deposit` / `otto_prepare_yield_withdraw` are the only paths.
+     */
+    for (const token of [input.fromToken, input.toToken]) {
+        if (modelBWithdrawToken(normalizedAddress(token))) {
+            return refuse('UNSUPPORTED_LIFI_ROUTE', `${token} is a Yield Copilot vault share token; use otto_prepare_yield_deposit / otto_prepare_yield_withdraw, which pin the registry row and check vault parity`);
+        }
+        // Same discipline for the executable equities (2026-09-03): a generic swap into a B20 token would
+        // reach the delegated gate as an indistinguishable swap artifact WITHOUT the registry commitment,
+        // the Chainlink price-parity guard and the freshness gate. The stock constructor is the only path.
+        if (EXECUTABLE_EQUITY_TOKEN_SET.has(token.toLowerCase())) {
+            return refuse('UNSUPPORTED_LIFI_ROUTE', `${token} is an executable tokenized equity; use otto_prepare_stock_buy, which pins the registry row and checks price parity against the equity's own Chainlink mark`);
+        }
+    }
+    const quote = await quoteSwap(runtime, input, signal);
+    return prepareSwapFromQuote(runtime, input, quote);
+}
+/** The swap's account profile, normalized; refuses a profile whose chain is not the swap's chain. */
+function swapProfile(input) {
     const profile = {
         kind: input.accountProfile.kind,
         address: normalizedAddress(input.accountProfile.address),
@@ -143,24 +196,114 @@ export async function prepareSwap(runtime, rawInput, signal) {
     if (profile.chainId !== input.chainId) {
         return refuse('ACCOUNT_BINDING_MISMATCH', 'account profile chain does not match swap chain');
     }
+    return profile;
+}
+/**
+ * The route-set and fee pre-checks, then ONE LI.FI quote for the parsed swap input. Split from
+ * `prepareSwapFromQuote` so a constructor that must read the quote itself (the Yield Copilot deposit:
+ * expected shares, the router's floor, the fee lines) quotes exactly once and builds the envelope from
+ * that same quote — a second quote could route through a different tool and carry a different floor.
+ */
+export async function quoteSwap(runtime, input, signal) {
+    const profile = swapProfile(input);
     if (!reviewedLiFiFeeForwarders(input.chainId)) {
         return refuse('UNSUPPORTED_LIFI_ROUTE', 'chain is outside the reviewed LI.FI v1 route set');
     }
-    const fromToken = normalizedAddress(input.fromToken);
-    const toToken = normalizedAddress(input.toToken);
     const fromAmount = BigInt(input.fromAmount);
     if (attributedFeeAmount(fromAmount, runtime.config.lifiFee) <= 0n) {
         return refuse('UNSUPPORTED_LIFI_ROUTE', 'input amount is too small for the configured Otto fee');
     }
-    const quote = await runtime.quoteClient.getSameChainSwapQuote({
-        chainId: input.chainId,
-        fromToken,
-        toToken,
-        fromAmount: input.fromAmount,
-        sender: profile.address,
-        receiver: profile.address,
-        maxSlippageBps: input.slippage.maxBps,
-    }, signal);
+    /**
+     * ══════════════════════════════════════════════════════════════════════════════════════════════
+     * 🔴 A ROUTE IS QUOTED ONLY ONCE IT HAS BEEN SEEN TO EXECUTE (2026-09-03, the first live delegated swap)
+     * ══════════════════════════════════════════════════════════════════════════════════════════════
+     * LI.FI picks the exchange tool per quote. That day it picked KyberSwap for a $1 USDC→WETH swap, and
+     * the diamond call reverted deterministically — at any gas, on a fresh quote too — while the same
+     * request through SushiSwap executed. Every assertion the constructor makes is about SHAPE (selector,
+     * receiver, fee, minimum output); none of them can see that a tool's calldata fails inside the diamond.
+     *
+     * So, on a server that has a chain view (the delegated rail's Base client), the quoted swap step is
+     * SIMULATED from the executing account with its preconditions overridden (balance and allowance to the
+     * spender — neither exists at prepare time). A route that reverts is re-quoted with that tool DENIED,
+     * bounded to `MAX_ROUTE_ATTEMPTS` tools; if none executes the quote refuses and names them. A
+     * simulation that cannot be run (no layout for the token, a node that ignores overrides) refuses too —
+     * an unproven route is not prepared on a server that was supposed to prove it.
+     *
+     * It lives HERE, in the one quote every swap-shaped constructor takes — the public swap and the Yield
+     * Copilot deposit/withdraw alike — so the quote a caller reads (expected shares, the floor, the fee
+     * lines) IS the quote that was proven, and `prepareSwapFromQuote` builds the envelope from exactly it.
+     * The proven tool and whether it was simulated ride on the returned quote (`route`), are recorded in
+     * the envelope's assertions, and the delegated receipt repeats them, so the receipt says which venue
+     * executed. A server without a chain view (the prepare-only x402 constructor) quotes as before and
+     * records `route_simulated:false`.
+     */
+    const fromToken = normalizedAddress(input.fromToken);
+    const toToken = normalizedAddress(input.toToken);
+    const denied = [];
+    for (let attempt = 1; attempt <= MAX_ROUTE_ATTEMPTS; attempt += 1) {
+        const quote = await runtime.quoteClient.getSameChainSwapQuote({
+            chainId: input.chainId,
+            fromToken,
+            toToken,
+            fromAmount: input.fromAmount,
+            sender: profile.address,
+            receiver: profile.address,
+            maxSlippageBps: input.slippage.maxBps,
+            // A COPY: the quote client must never see this list grow after it answered.
+            ...(denied.length > 0 ? { denyExchanges: Object.freeze([...denied]) } : {}),
+        }, signal);
+        const routeTool = typeof quote.tool === 'string' && quote.tool.trim() ? quote.tool.trim().slice(0, 48) : 'unknown';
+        if (!runtime.routeSimulator) {
+            return Object.freeze({ ...quote, route: Object.freeze({ tool: routeTool, simulated: false }) });
+        }
+        /**
+         * 🔴 SHAPE BEFORE SIMULATION (merge gate 2026-09-04). The quote is decoded and asserted HERE, on the
+         * quote-stage input, before the node sees it: a quote whose spender or target is not the diamond, whose
+         * selector, receiver, fee or floor is wrong, is refused by the assertion — it is never simulated, and a
+         * simulation that failed only because the quote's own `approvalAddress` was wrong can never deny a
+         * healthy tool. What the node simulates is the ASSERTED transaction and spender, the same bytes
+         * `prepareSwapFromQuote` asserts again (with the caller's floor) when it builds the envelope.
+         */
+        const asserted = decodeAndAssertLiFiSwap({
+            quote,
+            profile,
+            chainId: input.chainId,
+            fromToken,
+            toToken,
+            fromAmount,
+            maxSlippageBps: input.slippage.maxBps,
+            minAmountOut: input.slippage.minAmountOut ? BigInt(input.slippage.minAmountOut) : undefined,
+            config: runtime.config,
+        });
+        const simulation = await runtime.routeSimulator.simulate({
+            from: profile.address,
+            to: asserted.transaction.to,
+            data: asserted.transaction.data,
+            value: BigInt(asserted.transaction.value),
+            token: fromToken,
+            spender: asserted.approvalSpender,
+            amount: fromAmount,
+        });
+        if (simulation.outcome === 'ok') {
+            return Object.freeze({ ...quote, route: Object.freeze({ tool: routeTool, simulated: true }) });
+        }
+        if (simulation.outcome === 'unavailable') {
+            return refuse('UNSUPPORTED_LIFI_ROUTE', `[ROUTE_SIMULATION_UNAVAILABLE] the quoted route could not be simulated from ${profile.address}, so it is not prepared: ${simulation.detail}`);
+        }
+        denied.push(routeTool);
+        // A tool LI.FI did not name cannot be denied on the next quote; re-asking would only repeat it.
+        if (attempt === MAX_ROUTE_ATTEMPTS || routeTool === 'unknown') {
+            return refuse('UNSUPPORTED_LIFI_ROUTE', `[ROUTE_SIMULATION_REVERTED] no LI.FI route executes from ${profile.address} for this swap: tried ${denied.join(', ')} (last: ${simulation.detail})`);
+        }
+    }
+    return refuse('UNSUPPORTED_LIFI_ROUTE', 'no LI.FI quote was obtained');
+}
+/** Decode, assert and commit the envelope for a parsed swap input over the quote `quoteSwap` returned for it. */
+export function prepareSwapFromQuote(runtime, input, quote) {
+    const profile = swapProfile(input);
+    const fromToken = normalizedAddress(input.fromToken);
+    const toToken = normalizedAddress(input.toToken);
+    const fromAmount = BigInt(input.fromAmount);
     const asserted = decodeAndAssertLiFiSwap({
         quote,
         profile,
@@ -172,6 +315,13 @@ export async function prepareSwap(runtime, rawInput, signal) {
         minAmountOut: input.slippage.minAmountOut ? BigInt(input.slippage.minAmountOut) : undefined,
         config: runtime.config,
     });
+    // The route facts `quoteSwap` proved; a bare quote (a caller that quoted elsewhere) was not simulated.
+    const route = quote.route ?? {
+        tool: typeof quote.tool === 'string' && quote.tool.trim() ? quote.tool.trim().slice(0, 48) : 'unknown',
+        simulated: false,
+    };
+    const routeTool = route.tool;
+    const routeSimulated = route.simulated;
     const capability = capabilityFor(profile);
     const approvalCalldata = (amount) => encodeFunctionData({
         abi: ERC20_APPROVE_ABI,
@@ -230,6 +380,9 @@ export async function prepareSwap(runtime, rawInput, signal) {
         },
         assertions: [
             ...asserted.assertions,
+            // The route that was prepared, and whether it was proven to execute — repeated on the delegated receipt.
+            { id: `route_tool:${routeTool}`, result: 'passed' },
+            { id: `route_simulated:${routeSimulated}`, result: 'passed' },
             { id: 'payload_digest_committed', result: 'passed' },
             { id: 'erc20_allowance_reset_ordered', result: 'passed' },
             { id: 'artifact_expiry_committed', result: 'passed' },
@@ -528,6 +681,11 @@ export async function preparePolymarketOrder(runtime, rawInput, signal) {
  */
 export async function preparePerpOrder(runtime, rawInput, signal) {
     const input = PREPARE_PERP_ORDER_INPUT_SCHEMA.parse(rawInput);
+    // Kept for existing account recovery only, and deliberately absent from public discovery.
+    // Refuse before market reads, entropy, or an injected builder can construct new exposure.
+    if (input.reduceOnly !== true) {
+        return refuse('HYPERLIQUID_RETIRED', 'New Hyperliquid trading is retired; only explicit reduce-only recovery is supported');
+    }
     const profile = {
         kind: input.accountProfile.kind,
         address: normalizedAddress(input.accountProfile.address),

package/dist/execution-worker-guard.d.ts

@@ -0,0 +1,28 @@
+declare const KINDS: readonly ["delegated", "exit", "native", "sponsored"];
+export type ExecutionWorkerKind = (typeof KINDS)[number];
+export interface ExecutionWorkerGuard {
+    readonly kind: ExecutionWorkerKind;
+    readonly id: string;
+    release(): void;
+}
+export interface ExecutionWorkerGuardStore {
+    readonly available: boolean;
+    readonly unavailableReason?: string;
+    /** Create/validate the operation's permanent guard file and hold its writer lock until release. */
+    acquire(kind: ExecutionWorkerKind, id: string, create?: boolean): Promise<ExecutionWorkerGuard>;
+}
+export declare class ExecutionWorkerBusyError extends Error {
+    constructor();
+}
+export declare class ExecutionWorkerGuardInvalidError extends Error {
+    constructor();
+}
+export declare function unavailableExecutionWorkerGuardStore(reason: string): ExecutionWorkerGuardStore;
+/**
+ * The lock lives in a different SQLite file from operations.db. Holding BEGIN IMMEDIATE here therefore
+ * proves the prior handler is gone without blocking that same handler's durable journal transactions.
+ * The file and its exact metadata are permanent. Missing/corrupt metadata is a refusal, never evidence
+ * that an old owner died.
+ */
+export declare function openExecutionWorkerGuardStore(root: string): Promise<ExecutionWorkerGuardStore>;
+export {};

package/dist/execution-worker-guard.js

@@ -0,0 +1,124 @@
+import { access, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+const GUARD_ID = /^[a-zA-Z0-9_-]{8,128}$/;
+const KINDS = ['delegated', 'exit', 'native', 'sponsored'];
+export class ExecutionWorkerBusyError extends Error {
+    constructor() {
+        super('another worker still owns this operation');
+        this.name = 'ExecutionWorkerBusyError';
+    }
+}
+export class ExecutionWorkerGuardInvalidError extends Error {
+    constructor() {
+        super('the operation worker guard is missing, corrupt, or belongs to another operation');
+        this.name = 'ExecutionWorkerGuardInvalidError';
+    }
+}
+export function unavailableExecutionWorkerGuardStore(reason) {
+    return Object.freeze({
+        available: false,
+        unavailableReason: reason,
+        acquire: () => Promise.reject(new ExecutionWorkerGuardInvalidError()),
+    });
+}
+/**
+ * The lock lives in a different SQLite file from operations.db. Holding BEGIN IMMEDIATE here therefore
+ * proves the prior handler is gone without blocking that same handler's durable journal transactions.
+ * The file and its exact metadata are permanent. Missing/corrupt metadata is a refusal, never evidence
+ * that an old owner died.
+ */
+export async function openExecutionWorkerGuardStore(root) {
+    let DatabaseSync;
+    try {
+        const specifier = 'node:sqlite';
+        ({ DatabaseSync } = (await import(specifier)));
+    }
+    catch {
+        return unavailableExecutionWorkerGuardStore('this runtime has no node:sqlite worker locks');
+    }
+    const guardRoot = join(root, 'operation-guards');
+    try {
+        await mkdir(guardRoot, { recursive: true });
+    }
+    catch {
+        return unavailableExecutionWorkerGuardStore('the operation worker guard directory is unavailable');
+    }
+    return Object.freeze({
+        available: true,
+        async acquire(kind, id, create = false) {
+            if (!KINDS.includes(kind) || !GUARD_ID.test(id))
+                throw new ExecutionWorkerGuardInvalidError();
+            const path = join(guardRoot, `${kind}-${id}.db`);
+            let db;
+            try {
+                if (!create) {
+                    try {
+                        await access(path);
+                    }
+                    catch {
+                        throw new ExecutionWorkerGuardInvalidError();
+                    }
+                }
+                db = new DatabaseSync(path);
+                db.exec('PRAGMA journal_mode = WAL');
+                db.exec('PRAGMA synchronous = FULL');
+                db.exec('PRAGMA busy_timeout = 0');
+                if (create) {
+                    db.exec(`CREATE TABLE IF NOT EXISTS guard_meta (
+            singleton INTEGER NOT NULL PRIMARY KEY CHECK (singleton = 1),
+            kind      TEXT    NOT NULL CHECK (kind IN ('delegated','exit','native','sponsored')),
+            guard_id  TEXT    NOT NULL
+          )`);
+                    db.prepare('INSERT OR IGNORE INTO guard_meta (singleton, kind, guard_id) VALUES (1, ?, ?)')
+                        .run(kind, id);
+                }
+                const meta = db.prepare('SELECT kind, guard_id FROM guard_meta WHERE singleton = 1').get();
+                if (meta?.kind !== kind || meta?.guard_id !== id)
+                    throw new ExecutionWorkerGuardInvalidError();
+                try {
+                    db.exec('BEGIN IMMEDIATE');
+                }
+                catch {
+                    throw new ExecutionWorkerBusyError();
+                }
+                // Re-read under the held lock. Replacing the file or metadata can never manufacture liveness.
+                const held = db.prepare('SELECT kind, guard_id FROM guard_meta WHERE singleton = 1').get();
+                if (held?.kind !== kind || held?.guard_id !== id)
+                    throw new ExecutionWorkerGuardInvalidError();
+                let released = false;
+                return Object.freeze({
+                    kind,
+                    id,
+                    release() {
+                        if (released)
+                            return;
+                        released = true;
+                        try {
+                            db.exec('ROLLBACK');
+                        }
+                        catch { /* close still releases the OS lock */ }
+                        try {
+                            db.close();
+                        }
+                        catch { /* best effort */ }
+                    },
+                });
+            }
+            catch (error) {
+                try {
+                    db?.close();
+                }
+                catch { /* the original refusal stands */ }
+                if (error instanceof ExecutionWorkerBusyError || error instanceof ExecutionWorkerGuardInvalidError)
+                    throw error;
+                // node:sqlite currently reports both SQLITE_BUSY and SQLITE_LOCKED through ERR_SQLITE_ERROR;
+                // the stable distinction available here is its fixed engine message. Nothing upstream is relayed.
+                const detail = error instanceof Error ? error.message.toLowerCase() : '';
+                if (detail.includes('database is locked') || detail.includes('database is busy'))
+                    throw new ExecutionWorkerBusyError();
+                throw new ExecutionWorkerGuardInvalidError();
+            }
+        },
+    });
+}
+//# sourceMappingURL=execution-worker-guard.js.map

package/dist/hybrid-yield-index.d.ts

@@ -0,0 +1,10 @@
+/** Gated hybrid-yield library. Importing this module registers no MCP tool or signer authority. */
+export * from './hybrid-yield-markets.js';
+export * from './hybrid-yield.js';
+export * from './native-yield-definition.js';
+export * from './native-yield.js';
+export * from './native-yield-reader.js';
+export * from './native-yield-verify.js';
+export * from './native-yield-settlement.js';
+export * from './yield-route-semantics.js';
+export * from './native-yield-simulation.js';

package/dist/hybrid-yield-index.js

@@ -0,0 +1,11 @@
+/** Gated hybrid-yield library. Importing this module registers no MCP tool or signer authority. */
+export * from './hybrid-yield-markets.js';
+export * from './hybrid-yield.js';
+export * from './native-yield-definition.js';
+export * from './native-yield.js';
+export * from './native-yield-reader.js';
+export * from './native-yield-verify.js';
+export * from './native-yield-settlement.js';
+export * from './yield-route-semantics.js';
+export * from './native-yield-simulation.js';
+//# sourceMappingURL=hybrid-yield-index.js.map

package/dist/hybrid-yield-markets.d.ts

@@ -0,0 +1,96 @@
+import { type Address } from 'viem';
+export type HybridYieldChainId = 8453 | 42161;
+export type HybridYieldAction = 'deposit' | 'withdraw';
+export interface HybridYieldMarket {
+    readonly id: string;
+    readonly discoveryMarketId: string;
+    readonly chainId: HybridYieldChainId;
+    readonly chainSlug: 'base' | 'arbitrum';
+    readonly protocol: 'AAVE' | 'MORPHO';
+    readonly venue: string;
+    readonly asset: {
+        readonly address: Address;
+        readonly symbol: 'USDC' | 'WETH';
+        readonly decimals: 6 | 18;
+        readonly group: 'USDC' | 'ETH';
+        readonly assetClass: 'stable' | 'eth';
+    };
+    readonly position: {
+        readonly tokenAddress: Address;
+        readonly symbol: string;
+        readonly decimals: 6 | 18;
+        readonly kind: 'erc4626-shares' | 'rebasing-atoken';
+    };
+    readonly protocolTarget: Address;
+    readonly curation: {
+        readonly status: 'reviewed-candidate' | 'legacy-exit-only' | 'existing-supported';
+        readonly reviewedAt: '2026-09-10';
+        readonly rationale: string;
+        readonly risks: readonly string[];
+        readonly sources: readonly string[];
+    };
+    readonly capabilities: {
+        readonly native: {
+            readonly deposit: 'gated' | 'unavailable';
+            readonly withdraw: 'gated';
+            readonly reason: string;
+        };
+        readonly lifi: {
+            readonly deposit: 'existing-route' | 'unavailable';
+            readonly withdraw: 'existing-route' | 'unavailable';
+            readonly crossChain: 'gated';
+        };
+    };
+    /** Old pair used ONLY for the already-reviewed LI.FI constructor. */
+    readonly legacyRegistryCommitment: `sha256:${string}` | null;
+}
+export declare function freezeHybridValue<T>(value: T): T;
+export declare const HYBRID_YIELD_MARKETS: readonly HybridYieldMarket[];
+export declare function hybridYieldCommitment(value: unknown): `sha256:${string}`;
+export declare function getHybridYieldMarket(id: string): HybridYieldMarket | null;
+export declare function getHybridYieldCapabilities(): {
+    schemaVersion: "1";
+    markets: {
+        registryCommitment: `sha256:${string}`;
+        id: string;
+        discoveryMarketId: string;
+        chainId: HybridYieldChainId;
+        chainSlug: "base" | "arbitrum";
+        protocol: "AAVE" | "MORPHO";
+        venue: string;
+        asset: {
+            readonly address: Address;
+            readonly symbol: "USDC" | "WETH";
+            readonly decimals: 6 | 18;
+            readonly group: "USDC" | "ETH";
+            readonly assetClass: "stable" | "eth";
+        };
+        position: {
+            readonly tokenAddress: Address;
+            readonly symbol: string;
+            readonly decimals: 6 | 18;
+            readonly kind: "erc4626-shares" | "rebasing-atoken";
+        };
+        protocolTarget: Address;
+        curation: {
+            readonly status: "reviewed-candidate" | "legacy-exit-only" | "existing-supported";
+            readonly reviewedAt: "2026-09-10";
+            readonly rationale: string;
+            readonly risks: readonly string[];
+            readonly sources: readonly string[];
+        };
+        capabilities: {
+            readonly native: {
+                readonly deposit: "gated" | "unavailable";
+                readonly withdraw: "gated";
+                readonly reason: string;
+            };
+            readonly lifi: {
+                readonly deposit: "existing-route" | "unavailable";
+                readonly withdraw: "existing-route" | "unavailable";
+                readonly crossChain: "gated";
+            };
+        };
+        legacyRegistryCommitment: `sha256:${string}` | null;
+    }[];
+};

package/dist/hybrid-yield-markets.js

@@ -0,0 +1,124 @@
+/**
+ * Chain-general capability registry for hybrid Yield. These records DO NOT extend
+ * the legacy TEA/Safe or CDP allowlist in executable-yield-markets.ts.
+ * Curation evidence: docs/0910_hybrid_yield_curation.md (10 September 2026).
+ */
+import { createHash } from 'node:crypto';
+import { getAddress } from 'viem';
+import { BASE_USDC_MORPHO_GAUNTLET_PRIME_MARKET, BASE_USDC_MORPHO_STEAKHOUSE_PRIME_MARKET, getExecutableYieldMarketCommitment, } from './executable-yield-markets.js';
+export function freezeHybridValue(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            freezeHybridValue(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+const NATIVE_GATE = 'Requires reviewed native executor deployment, chain/account policy, limits and funded acceptance; registry membership grants no signing authority.';
+const AAVE_RISKS = [
+    'Aave Pool and reserve configuration can be upgraded by governance.',
+    'Supply yield and available withdrawal liquidity vary with utilization; instant liquidity is not guaranteed.',
+    'Underlying token, oracle, bad-debt and chain risks remain; a protocol review is not a safety guarantee.',
+];
+const MORPHO_RISKS = [
+    'The vault curator chooses collateral markets, oracles and caps; review the exact vault, not only Morpho.',
+    'Borrower liquidation, bad debt, curator changes and depleted liquidity can impair value or delay exits.',
+    'USDC issuer/peg and Base network risks remain; APY is variable and not a guarantee.',
+];
+function aave(chainId, symbol, assetAddress, pool, receiptAddress, receiptSymbol) {
+    const chainSlug = chainId === 8453 ? 'base' : 'arbitrum';
+    return {
+        id: `${chainSlug}-${symbol.toLowerCase()}-aave-v3`,
+        discoveryMarketId: `aave:${chainId}:${pool.toLowerCase()}:${assetAddress.toLowerCase()}`,
+        chainId, chainSlug, protocol: 'AAVE', venue: `Aave V3 · ${symbol}`,
+        asset: {
+            address: getAddress(assetAddress), symbol, decimals: symbol === 'USDC' ? 6 : 18,
+            group: symbol === 'USDC' ? 'USDC' : 'ETH', assetClass: symbol === 'USDC' ? 'stable' : 'eth',
+        },
+        position: {
+            tokenAddress: getAddress(receiptAddress), symbol: receiptSymbol,
+            decimals: symbol === 'USDC' ? 6 : 18, kind: 'rebasing-atoken',
+        },
+        protocolTarget: getAddress(pool),
+        curation: {
+            status: 'reviewed-candidate', reviewedAt: '2026-09-10',
+            rationale: symbol === 'USDC'
+                ? 'Established already-integrated lending protocol; exact native USDC reserve and receipt token verified. Candidate by integration/exit fit, not highest APY.'
+                : 'Separate ETH-denominated lending exposure using plain WETH. This is lending, not staking, and accepts neither native ETH nor a liquid-staking token.',
+            risks: AAVE_RISKS,
+            sources: [
+                `https://github.com/aave-dao/aave-address-book/blob/main/src/AaveV3${chainId === 8453 ? 'Base' : 'Arbitrum'}.sol`,
+                'https://aave.com/docs/aave-v3/smart-contracts/pool',
+            ],
+        },
+        capabilities: {
+            native: { deposit: 'gated', withdraw: 'gated', reason: NATIVE_GATE },
+            lifi: { deposit: 'unavailable', withdraw: 'unavailable', crossChain: 'gated' },
+        },
+        legacyRegistryCommitment: null,
+    };
+}
+function morpho(old, legacy) {
+    return {
+        id: old.id, discoveryMarketId: old.discoveryMarketId, chainId: 8453, chainSlug: 'base',
+        protocol: 'MORPHO', venue: old.venue,
+        asset: { ...old.asset, address: getAddress(old.asset.address), assetClass: 'stable' },
+        position: {
+            tokenAddress: getAddress(old.vaultAddress), symbol: legacy ? 'steakUSDC' : 'gtUSDCp',
+            decimals: old.vaultShareDecimals, kind: 'erc4626-shares',
+        },
+        protocolTarget: getAddress(old.protocolTarget),
+        curation: {
+            status: legacy ? 'legacy-exit-only' : 'existing-supported', reviewedAt: '2026-09-10',
+            rationale: legacy
+                ? 'Steakhouse lists this exact vault as operational but deprioritized/superseded. Retain the position and exit; do not promote new allocations.'
+                : 'Retained exact previously supported vault identity. A technical execution pin is not a best-yield ranking or blanket curator approval.',
+            risks: MORPHO_RISKS,
+            sources: [
+                `https://app.morpho.org/base/vault/${old.vaultAddress}`,
+                ...(legacy ? ['https://www.steakhouse.financial/docs/products/vault-products/legacy-vaults'] : []),
+            ],
+        },
+        capabilities: {
+            native: { deposit: legacy ? 'unavailable' : 'gated', withdraw: 'gated', reason: NATIVE_GATE },
+            // Legacy positions remain routable for exit; new preparation is disabled.
+            lifi: { deposit: legacy ? 'unavailable' : 'existing-route', withdraw: 'existing-route', crossChain: 'gated' },
+        },
+        legacyRegistryCommitment: getExecutableYieldMarketCommitment(old),
+    };
+}
+export const HYBRID_YIELD_MARKETS = freezeHybridValue([
+    aave(8453, 'USDC', '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5', '0x4e65fE4DbA92790696d040ac24Aa414708F5c0AB', 'aBasUSDC'),
+    aave(8453, 'WETH', '0x4200000000000000000000000000000000000006', '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5', '0xD4a0e0b9149BCee3C920d2E00b5dE09138fd8bb7', 'aBasWETH'),
+    aave(42161, 'USDC', '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', '0x794a61358D6845594F94dc1DB02A252b5b4814aD', '0x724dc807b04555b71ed48a6896b6F41593b8C637', 'aArbUSDCn'),
+    aave(42161, 'WETH', '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', '0x794a61358D6845594F94dc1DB02A252b5b4814aD', '0xe50fA9b3c56FfB159cB0FCA61F5c9D750e8128c8', 'aArbWETH'),
+    morpho(BASE_USDC_MORPHO_GAUNTLET_PRIME_MARKET, false),
+    morpho(BASE_USDC_MORPHO_STEAKHOUSE_PRIME_MARKET, true),
+]);
+function canonical(value) {
+    if (value === null || ['string', 'boolean'].includes(typeof value))
+        return JSON.stringify(value);
+    if (typeof value === 'number' && Number.isFinite(value))
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (typeof value === 'object')
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(',')}}`;
+    throw new Error('Non-canonical hybrid yield value');
+}
+export function hybridYieldCommitment(value) {
+    return `sha256:${createHash('sha256').update('otto:hybrid-yield:v1:' + canonical(value)).digest('hex')}`;
+}
+export function getHybridYieldMarket(id) {
+    return HYBRID_YIELD_MARKETS.find((m) => m.id === id) ?? null;
+}
+export function getHybridYieldCapabilities() {
+    return freezeHybridValue({
+        schemaVersion: '1',
+        markets: HYBRID_YIELD_MARKETS.map((market) => ({
+            ...market, registryCommitment: hybridYieldCommitment(market),
+        })),
+    });
+}
+//# sourceMappingURL=hybrid-yield-markets.js.map