otto-intel-mcp 0.1.2 → 0.1.3

package/dist/adapter/route-simulator.d.ts

@@ -0,0 +1,91 @@
+/**
+ * route-simulator.ts — proves a quoted swap's calldata EXECUTES before it is ever prepared for a signer.
+ *
+ * 🔴 WHY (2026-09-03, the first live delegated swap): LI.FI routed a $1 USDC→WETH quote through KyberSwap
+ * and the diamond call reverted deterministically ("Call failed") — at any gas, on a fresh quote too —
+ * while the same request routed through SushiSwap executed. The constructor had passed the calldata
+ * verbatim and pinned no tool. A static allowlist rots; a simulation from the executing account does not.
+ *
+ * HOW: `eth_call` of the swap step from the account that will sign it, at `latest`, with the input token's
+ * balance and its allowance to the spender OVERRIDDEN to the amount the plan approves — because at prepare
+ * time neither exists yet (the approve is the plan's own step 1). The override needs the token's storage
+ * layout; the table below holds every token a v1 constructor may hand in as the swap's input: USDC on Base
+ * (FiatTokenV2: `balances` at slot 9, `allowed` at slot 10) and the two Yield Copilot share tokens the
+ * delegated WITHDRAW sells (MetaMorpho vaults on plain OpenZeppelin ERC20: `_balances` at 0, `_allowances`
+ * at 1). 🔴 A LAYOUT IS ADDED ONLY ONCE IT HAS BEEN PROVEN LIVE with this module's own probe read-back on
+ * the production RPC (merge gate 2026-09-04: the withdraw's share token had no layout, so a hosted withdraw
+ * refused as `unavailable`); a token whose layout is not in the table — or does not read back — is refused
+ * by name, never simulated by guesswork and never passed unsimulated.
+ *
+ * 🔴 THE OVERRIDE IS PROVEN BEFORE THE STEP IS JUDGED, AND PROVEN ON BOTH SLOTS WITH PROBE VALUES NO REAL
+ * ACCOUNT HOLDS (gate r7, finding 4): a node that silently ignores overrides, or a token whose slots differ,
+ * is caught even when the account's real balance happens to equal the plan amount. A layout that does not
+ * read back is `unavailable`, never a pass.
+ *
+ * 🔴 A STEP THE NODE COULD NOT RUN IS NOT A REVERT (gate r7, finding 3): a timeout, a rate limit or a
+ * dropped connection during the step call is `unavailable` — the route is not blamed and not denied —
+ * while only a PROVEN revert (`adapter/evm-call-failure.ts`) is `reverted`.
+ *
+ * Verified on the production RPC 2026-09-03 (overridden balance read back exactly; the Sushi calldata
+ * simulated OK; Kyber's reverted). Nothing here prints the RPC URL.
+ */
+import type { Address, Hex, PublicClient } from 'viem';
+export type RouteSimulation = {
+    readonly outcome: 'ok';
+} | {
+    readonly outcome: 'reverted';
+    readonly detail: string;
+} | {
+    readonly outcome: 'unavailable';
+    readonly detail: string;
+};
+export interface RouteSimulationRequest {
+    /** The account that will sign and send the plan. */
+    readonly from: Address;
+    /** The swap step, exactly as it will be sent. */
+    readonly to: Address;
+    readonly data: Hex;
+    readonly value: bigint;
+    /** The ERC20 the plan spends, the spender it approves, and the amount — the state the step assumes. */
+    readonly token: Address;
+    readonly spender: Address;
+    readonly amount: bigint;
+}
+export interface RouteSimulator {
+    simulate(request: RouteSimulationRequest): Promise<RouteSimulation>;
+}
+/** Storage layout of an ERC20 whose `balances` and `allowed` mappings this simulator can override. */
+export interface Erc20StorageLayout {
+    readonly balancesSlot: bigint;
+    readonly allowancesSlot: bigint;
+}
+/** Circle's FiatTokenV2 (USDC): `mapping(address => uint256) balances` at 9, `allowed` at 10. */
+export declare const FIAT_TOKEN_V2_LAYOUT: Erc20StorageLayout;
+/** Plain (non-upgradeable) OpenZeppelin ERC20: `_balances` at slot 0, `_allowances` at slot 1. */
+export declare const OPENZEPPELIN_ERC20_LAYOUT: Erc20StorageLayout;
+/**
+ * Tokens whose layout is known, by lowercase address — every input token a v1 swap-shaped constructor can
+ * produce. Each entry was proven on the production Base RPC on the date given, by writing the probe values
+ * into the candidate slots with `eth_call` state overrides and reading them back through `balanceOf` /
+ * `allowance` (exactly `createRouteSimulator`'s proof); of the candidate layouts tried (plain OZ 0/1, OZ v5
+ * ERC-7201 namespace, OZ v4 upgradeable 51/52, FiatTokenV2 9/10, Aave aToken 52/53) exactly one read back
+ * for each token. `test/route-simulator.test.ts` pins that every fence-permitted withdraw share token is here.
+ */
+export declare const KNOWN_ERC20_LAYOUTS: ReadonlyMap<string, Erc20StorageLayout>;
+/**
+ * The two probe values the proof writes: far above any real ERC20 balance (2^200), distinct from each
+ * other, and distinct from the plan amount — so a node that ignores the override cannot pass the proof by
+ * coincidence, whatever the account really holds.
+ */
+export declare const PROBE_BALANCE: bigint;
+export declare const PROBE_ALLOWANCE: bigint;
+/** The two storage words that make the step's preconditions true for this account. */
+export declare function erc20OverrideSlots(layout: Erc20StorageLayout, owner: Address, spender: Address): {
+    readonly balance: Hex;
+    readonly allowance: Hex;
+};
+/**
+ * The production simulator over a viem public client. `layouts` defaults to the known table; a token
+ * without a layout is `unavailable` (the constructor then refuses rather than guessing).
+ */
+export declare function createRouteSimulator(pub: Pick<PublicClient, 'call'>, layouts?: ReadonlyMap<string, Erc20StorageLayout>): RouteSimulator;

package/dist/adapter/route-simulator.js

@@ -0,0 +1,143 @@
+/**
+ * route-simulator.ts — proves a quoted swap's calldata EXECUTES before it is ever prepared for a signer.
+ *
+ * 🔴 WHY (2026-09-03, the first live delegated swap): LI.FI routed a $1 USDC→WETH quote through KyberSwap
+ * and the diamond call reverted deterministically ("Call failed") — at any gas, on a fresh quote too —
+ * while the same request routed through SushiSwap executed. The constructor had passed the calldata
+ * verbatim and pinned no tool. A static allowlist rots; a simulation from the executing account does not.
+ *
+ * HOW: `eth_call` of the swap step from the account that will sign it, at `latest`, with the input token's
+ * balance and its allowance to the spender OVERRIDDEN to the amount the plan approves — because at prepare
+ * time neither exists yet (the approve is the plan's own step 1). The override needs the token's storage
+ * layout; the table below holds every token a v1 constructor may hand in as the swap's input: USDC on Base
+ * (FiatTokenV2: `balances` at slot 9, `allowed` at slot 10) and the two Yield Copilot share tokens the
+ * delegated WITHDRAW sells (MetaMorpho vaults on plain OpenZeppelin ERC20: `_balances` at 0, `_allowances`
+ * at 1). 🔴 A LAYOUT IS ADDED ONLY ONCE IT HAS BEEN PROVEN LIVE with this module's own probe read-back on
+ * the production RPC (merge gate 2026-09-04: the withdraw's share token had no layout, so a hosted withdraw
+ * refused as `unavailable`); a token whose layout is not in the table — or does not read back — is refused
+ * by name, never simulated by guesswork and never passed unsimulated.
+ *
+ * 🔴 THE OVERRIDE IS PROVEN BEFORE THE STEP IS JUDGED, AND PROVEN ON BOTH SLOTS WITH PROBE VALUES NO REAL
+ * ACCOUNT HOLDS (gate r7, finding 4): a node that silently ignores overrides, or a token whose slots differ,
+ * is caught even when the account's real balance happens to equal the plan amount. A layout that does not
+ * read back is `unavailable`, never a pass.
+ *
+ * 🔴 A STEP THE NODE COULD NOT RUN IS NOT A REVERT (gate r7, finding 3): a timeout, a rate limit or a
+ * dropped connection during the step call is `unavailable` — the route is not blamed and not denied —
+ * while only a PROVEN revert (`adapter/evm-call-failure.ts`) is `reverted`.
+ *
+ * Verified on the production RPC 2026-09-03 (overridden balance read back exactly; the Sushi calldata
+ * simulated OK; Kyber's reverted). Nothing here prints the RPC URL.
+ */
+import { encodeAbiParameters, encodeFunctionData, keccak256, pad, parseAbi, toHex } from 'viem';
+import { classifyEvmCallFailure, evmCallFailureDetail } from './evm-call-failure.js';
+/** Circle's FiatTokenV2 (USDC): `mapping(address => uint256) balances` at 9, `allowed` at 10. */
+export const FIAT_TOKEN_V2_LAYOUT = Object.freeze({ balancesSlot: 9n, allowancesSlot: 10n });
+/** Plain (non-upgradeable) OpenZeppelin ERC20: `_balances` at slot 0, `_allowances` at slot 1. */
+export const OPENZEPPELIN_ERC20_LAYOUT = Object.freeze({ balancesSlot: 0n, allowancesSlot: 1n });
+/**
+ * Tokens whose layout is known, by lowercase address — every input token a v1 swap-shaped constructor can
+ * produce. Each entry was proven on the production Base RPC on the date given, by writing the probe values
+ * into the candidate slots with `eth_call` state overrides and reading them back through `balanceOf` /
+ * `allowance` (exactly `createRouteSimulator`'s proof); of the candidate layouts tried (plain OZ 0/1, OZ v5
+ * ERC-7201 namespace, OZ v4 upgradeable 51/52, FiatTokenV2 9/10, Aave aToken 52/53) exactly one read back
+ * for each token. `test/route-simulator.test.ts` pins that every fence-permitted withdraw share token is here.
+ */
+export const KNOWN_ERC20_LAYOUTS = new Map([
+    // USDC on Base (FiatTokenV2) — proven 2026-09-03.
+    ['0x833589fcd6edb6e08f4c7c32d4f71b54bda02913', FIAT_TOKEN_V2_LAYOUT],
+    // gtUSDCp — Gauntlet USDC Prime, MetaMorpho vault share on Base — proven 2026-09-04.
+    ['0xee8f4ec5672f09119b96ab6fb59c27e1b7e44b61', OPENZEPPELIN_ERC20_LAYOUT],
+    // steakUSDC — Steakhouse USDC, MetaMorpho vault share on Base — proven 2026-09-04.
+    ['0xbeefe94c8ad530842bfe7d8b397938ffc1cb83b2', OPENZEPPELIN_ERC20_LAYOUT],
+]);
+/**
+ * The two probe values the proof writes: far above any real ERC20 balance (2^200), distinct from each
+ * other, and distinct from the plan amount — so a node that ignores the override cannot pass the proof by
+ * coincidence, whatever the account really holds.
+ */
+export const PROBE_BALANCE = (1n << 200n) + 7n;
+export const PROBE_ALLOWANCE = (1n << 200n) + 11n;
+const ERC20_VIEW_ABI = parseAbi([
+    'function balanceOf(address owner) view returns (uint256)',
+    'function allowance(address owner, address spender) view returns (uint256)',
+]);
+function mappingSlot(key, slot) {
+    return keccak256(encodeAbiParameters([{ type: 'bytes32' }, { type: 'bytes32' }], [key, slot]));
+}
+/** The two storage words that make the step's preconditions true for this account. */
+export function erc20OverrideSlots(layout, owner, spender) {
+    const ownerKey = pad(owner, { size: 32 });
+    const balance = mappingSlot(ownerKey, pad(toHex(layout.balancesSlot), { size: 32 }));
+    const inner = mappingSlot(ownerKey, pad(toHex(layout.allowancesSlot), { size: 32 }));
+    const allowance = mappingSlot(pad(spender, { size: 32 }), inner);
+    return { balance, allowance };
+}
+function overrideFor(token, slots, balance, allowance) {
+    return [
+        {
+            address: token,
+            stateDiff: [
+                { slot: slots.balance, value: pad(toHex(balance), { size: 32 }) },
+                { slot: slots.allowance, value: pad(toHex(allowance), { size: 32 }) },
+            ],
+        },
+    ];
+}
+/**
+ * The production simulator over a viem public client. `layouts` defaults to the known table; a token
+ * without a layout is `unavailable` (the constructor then refuses rather than guessing).
+ */
+export function createRouteSimulator(pub, layouts = KNOWN_ERC20_LAYOUTS) {
+    return Object.freeze({
+        async simulate(request) {
+            const layout = layouts.get(request.token.toLowerCase());
+            if (!layout)
+                return { outcome: 'unavailable', detail: `no storage layout is known for token ${request.token}` };
+            const slots = erc20OverrideSlots(layout, request.from, request.spender);
+            // (1) PROVE the override on BOTH slots, with probe values no real account holds.
+            const probe = overrideFor(request.token, slots, PROBE_BALANCE, PROBE_ALLOWANCE);
+            try {
+                const balance = await pub.call({
+                    to: request.token,
+                    data: encodeFunctionData({ abi: ERC20_VIEW_ABI, functionName: 'balanceOf', args: [request.from] }),
+                    stateOverride: probe,
+                });
+                const allowance = await pub.call({
+                    to: request.token,
+                    data: encodeFunctionData({ abi: ERC20_VIEW_ABI, functionName: 'allowance', args: [request.from, request.spender] }),
+                    stateOverride: probe,
+                });
+                const seenBalance = balance.data ? BigInt(balance.data) : -1n;
+                const seenAllowance = allowance.data ? BigInt(allowance.data) : -1n;
+                if (seenBalance !== PROBE_BALANCE || seenAllowance !== PROBE_ALLOWANCE) {
+                    return {
+                        outcome: 'unavailable',
+                        detail: `the state override did not take: balanceOf read ${seenBalance}, allowance read ${seenAllowance}`,
+                    };
+                }
+            }
+            catch (error) {
+                return { outcome: 'unavailable', detail: `the state-override proof failed: ${evmCallFailureDetail(error)}` };
+            }
+            // (2) The step itself, from the signer's account, under the plan's own preconditions.
+            try {
+                await pub.call({
+                    account: request.from,
+                    to: request.to,
+                    data: request.data,
+                    value: request.value,
+                    stateOverride: overrideFor(request.token, slots, request.amount, request.amount),
+                });
+                return { outcome: 'ok' };
+            }
+            catch (error) {
+                // Only a PROVEN revert blames the route; a node that could not run the call proves nothing.
+                return classifyEvmCallFailure(error) === 'revert'
+                    ? { outcome: 'reverted', detail: evmCallFailureDetail(error) }
+                    : { outcome: 'unavailable', detail: `the step could not be simulated: ${evmCallFailureDetail(error)}` };
+            }
+        },
+    });
+}
+//# sourceMappingURL=route-simulator.js.map

package/dist/executable-equities.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Server-owned executable tokenized-equity registry — the Coinbase B20 venue on Base ONLY
+ * (Founder word `delegate` beyond swaps, 2026-09-03).
+ *
+ * LIVENESS (gate G4, live-derived 2026-09-04): only the B20 names whose pools actually QUOTE are
+ * executable — a $25 li.quest probe of all 13 B20 rows returned routes for exactly these EIGHT
+ * (AAPL AMZN GOOGL META MSTR NVDA SPCX TSLA); COIN/CRCL/INTC/MSFT/SNDK had no available quotes and
+ * are NOT rows here — an executable name that can never prepare is a lie of the registry, not a
+ * refusal. Re-derive when pools appear: re-run the $25 probe over the dApp registry's b20 rows and
+ * re-add the names that quote (the parity test pins every row byte-identical to the dApp registry).
+ *
+ * WHY B20/BASE ONLY: a delegated stock BUY must stay inside the fence as it stands —
+ * USDC (allow-listed input) → an ERC-20 through the diamond's two fenced GenericSwapV3
+ * entry points, output to the signing account, on Base where the delegation lives. Every
+ * other venue is another chain (Robinhood Chain / BNB / Solana) or would need new fence
+ * rules; those are sized in docs/0903_delegation_empire_scope.md, not shipped here.
+ *
+ * The rows are a byte-identical copy of the dApp's generated registry
+ * (src/lib/stocks-terminal/registry.generated.ts, b20 venue: address / decimals / feed
+ * read ON-CHAIN at generation) — a parity test asserts the copy against that file, the
+ * same discipline as the executable-yield registry's TEA copy. Do NOT hand-edit
+ * addresses; regenerate the dApp registry and re-copy.
+ *
+ * The commitment mechanism is the yield registry's, with its own domain tag.
+ */
+export interface ExecutableEquity {
+    readonly id: string;
+    readonly venue: 'COINBASE_B20';
+    readonly chainId: 8453;
+    readonly chainSlug: 'base';
+    readonly underlying: string;
+    readonly symbol: string;
+    /** The B20 wrapped-equity ERC-20 on Base — the swap's OUTPUT token, never a caller input. */
+    readonly tokenAddress: `0x${string}`;
+    readonly tokenDecimals: 8;
+    /** Chainlink total-return feed on Base (8 decimals) — the price-parity reference. */
+    readonly feed: `0x${string}`;
+    readonly asset: {
+        readonly symbol: 'USDC';
+        readonly address: `0x${string}`;
+        readonly decimals: 6;
+    };
+}
+export declare const EXECUTABLE_EQUITIES: readonly [ExecutableEquity, ExecutableEquity, ExecutableEquity, ExecutableEquity, ExecutableEquity, ExecutableEquity, ExecutableEquity, ExecutableEquity];
+/** All 13 known B20 token addresses (executable + not-yet-executable), lowercased. */
+export declare const KNOWN_B20_TOKENS: readonly string[];
+export type ExecutableEquityCommitment = `sha256:${string}`;
+/** SHA-256 commitment over every enumerable field in the complete, canonical registry record. */
+export declare function getExecutableEquityCommitment(equity: ExecutableEquity): ExecutableEquityCommitment;
+export declare function getExecutableEquity(equityId: string): ExecutableEquity | null;
+/**
+ * The generic-swap refusal set: EVERY known B20 token, not just the executable ones (gate r2 —
+ * see KNOWN_B20_TOKENS for why the deny plane is wider than the prepare plane).
+ */
+export declare const EXECUTABLE_EQUITY_TOKEN_SET: ReadonlySet<string>;

package/dist/executable-equities.js

@@ -0,0 +1,116 @@
+/**
+ * Server-owned executable tokenized-equity registry — the Coinbase B20 venue on Base ONLY
+ * (Founder word `delegate` beyond swaps, 2026-09-03).
+ *
+ * LIVENESS (gate G4, live-derived 2026-09-04): only the B20 names whose pools actually QUOTE are
+ * executable — a $25 li.quest probe of all 13 B20 rows returned routes for exactly these EIGHT
+ * (AAPL AMZN GOOGL META MSTR NVDA SPCX TSLA); COIN/CRCL/INTC/MSFT/SNDK had no available quotes and
+ * are NOT rows here — an executable name that can never prepare is a lie of the registry, not a
+ * refusal. Re-derive when pools appear: re-run the $25 probe over the dApp registry's b20 rows and
+ * re-add the names that quote (the parity test pins every row byte-identical to the dApp registry).
+ *
+ * WHY B20/BASE ONLY: a delegated stock BUY must stay inside the fence as it stands —
+ * USDC (allow-listed input) → an ERC-20 through the diamond's two fenced GenericSwapV3
+ * entry points, output to the signing account, on Base where the delegation lives. Every
+ * other venue is another chain (Robinhood Chain / BNB / Solana) or would need new fence
+ * rules; those are sized in docs/0903_delegation_empire_scope.md, not shipped here.
+ *
+ * The rows are a byte-identical copy of the dApp's generated registry
+ * (src/lib/stocks-terminal/registry.generated.ts, b20 venue: address / decimals / feed
+ * read ON-CHAIN at generation) — a parity test asserts the copy against that file, the
+ * same discipline as the executable-yield registry's TEA copy. Do NOT hand-edit
+ * addresses; regenerate the dApp registry and re-copy.
+ *
+ * The commitment mechanism is the yield registry's, with its own domain tag.
+ */
+import { createHash } from 'node:crypto';
+const USDC_BASE = {
+    symbol: 'USDC',
+    address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+    decimals: 6,
+};
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        for (const nested of Object.values(value))
+            deepFreeze(nested);
+        Object.freeze(value);
+    }
+    return value;
+}
+const row = (underlying, symbol, tokenAddress, feed) => ({
+    id: `b20-${underlying.toLowerCase()}`,
+    venue: 'COINBASE_B20',
+    chainId: 8453,
+    chainSlug: 'base',
+    underlying,
+    symbol,
+    tokenAddress,
+    tokenDecimals: 8,
+    feed,
+    asset: USDC_BASE,
+});
+export const EXECUTABLE_EQUITIES = deepFreeze([
+    row('AAPL', 'AAPLc', '0xb200000000000000000000C2e324d24d7eEcd1fb', '0x787f13dEa48Db0897CbCDD985de77809D837F988'),
+    row('AMZN', 'AMZNc', '0xb200000000000000000000d9192b6B456483C2E8', '0x06A8E4b3aBB3B7543d8396FB2B763d22820cB295'),
+    row('GOOGL', 'GOOGLc', '0xb2000000000000000000002D0BA3164cc74f58B7', '0x5bF49E0ffA937CE2FfF033c739aD7C634c4D34F2'),
+    row('META', 'METAc', '0xb2000000000000000000008bC8786B856E61707C', '0x6526aE6797A76123638b863AeE4dD27Ba4E4b27D'),
+    row('MSTR', 'MSTRc', '0xb2000000000000000000004884b426556b92883d', '0xB3cE282CD188b35DA0E38D8Bc7d58e33173D202a'),
+    row('NVDA', 'NVDAc', '0xb20000000000000000000078ee7ce2fE4908108C', '0x04689a41629776563E6822F76f2e57D148d28513'),
+    row('SPCX', 'SPCXc', '0xb2000000000000000000007b9fcbd005511aCBd5', '0x6A634B235903C4ad6376892180d6fF8612e3Fa68'),
+    row('TSLA', 'TSLAc', '0xb2000000000000000000001e800a7f5189430cD0', '0xFaf869185383a24F8cb00e27BdA6b63B9905DCb4'),
+]);
+/**
+ * 🔴 EVERY KNOWN B20 TOKEN ON BASE — the DENY plane, which is NOT the executable plane (gate r2).
+ *
+ * The executable list above is the live-quoting subset; this is all 13 rows the dApp registry
+ * carries. The generic `otto_prepare_swap` must refuse the WHOLE class: if one of the five that
+ * cannot quote today gains (or intermittently exposes) a pool before anyone re-derives the
+ * executable set, a generic USDC→B20 swap would otherwise prepare and submit inside the fence with
+ * NONE of this constructor's guards — no registry commitment, no oracle freshness, no price parity.
+ * Deny is derived from the known universe; prepare is derived from what actually quotes.
+ * The parity test pins every address here against the dApp's generated registry.
+ */
+const NON_EXECUTABLE_B20_TOKENS = [
+    '0xb200000000000000000000c85a31389D71F3ecfb', // COINc — no route 2026-09-04
+    '0xB20000000000000000000019f6E7C675b73C2e4D', // CRCLc — no route 2026-09-04
+    '0xB2000000000000000000004AFF16039bA04bdFBc', // INTCc — no route 2026-09-04
+    '0xB200000000000000000000Ab99cFa739E253872B', // MSFTc — no route 2026-09-04
+    '0xb200000000000000000000397293Cb8cda9a10c5', // SNDKc — no route 2026-09-04
+];
+/** All 13 known B20 token addresses (executable + not-yet-executable), lowercased. */
+export const KNOWN_B20_TOKENS = Object.freeze([
+    ...EXECUTABLE_EQUITIES.map((equity) => equity.tokenAddress.toLowerCase()),
+    ...NON_EXECUTABLE_B20_TOKENS.map((address) => address.toLowerCase()),
+]);
+function canonicalJson(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new Error('executable equity registry contains a non-finite number');
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (typeof value === 'object') {
+        const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+        return `{${entries.map(([key, nested]) => `${JSON.stringify(key)}:${canonicalJson(nested)}`).join(',')}}`;
+    }
+    throw new Error('executable equity registry contains a non-canonical value');
+}
+/** SHA-256 commitment over every enumerable field in the complete, canonical registry record. */
+export function getExecutableEquityCommitment(equity) {
+    const canonical = canonicalJson(equity);
+    const digest = createHash('sha256').update(`otto:executable-equity:v1:${canonical}`, 'utf8').digest('hex');
+    return `sha256:${digest}`;
+}
+export function getExecutableEquity(equityId) {
+    return EXECUTABLE_EQUITIES.find((equity) => equity.id === equityId) ?? null;
+}
+/**
+ * The generic-swap refusal set: EVERY known B20 token, not just the executable ones (gate r2 —
+ * see KNOWN_B20_TOKENS for why the deny plane is wider than the prepare plane).
+ */
+export const EXECUTABLE_EQUITY_TOKEN_SET = new Set(KNOWN_B20_TOKENS);
+//# sourceMappingURL=executable-equities.js.map

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

@@ -0,0 +1,261 @@
+/**
+ * Server-owned yield execution registry.
+ *
+ * The dApp's server route and TEA import the exact same records. Discovery can
+ * attach APY data to a record, but it cannot create or mutate execution
+ * eligibility. The canonical commitment is server-only (both consumers run in
+ * Node) and covers the complete registry record, including nested fields.
+ */
+export type ExecutableYieldAction = 'deposit' | 'withdraw';
+export type ExecutableYieldCall = 'approve' | 'supply' | 'deposit' | 'withdraw' | 'redeem';
+interface ExecutableYieldMarketBase {
+    readonly id: string;
+    readonly venue: string;
+    readonly chainId: 8453;
+    readonly chainSlug: 'base';
+    readonly asset: {
+        readonly symbol: 'USDC';
+        readonly group: 'USDC';
+        readonly address: `0x${string}`;
+        readonly decimals: 6;
+    };
+    /** Exact protocol call target (Aave Pool proxy or per-vault Morpho ERC-4626). */
+    readonly protocolTarget: `0x${string}`;
+    readonly vaultAddress: `0x${string}`;
+    readonly nativeValue: '0';
+    readonly allowedCallSequences: {
+        readonly deposit: readonly (readonly ExecutableYieldCall[])[];
+        readonly withdraw: readonly (readonly ExecutableYieldCall[])[];
+    };
+    readonly safeBinding: {
+        readonly executionOwner: 'SAFE';
+        readonly depositReceiver: 'SAFE';
+        readonly withdrawReceiver: 'SAFE';
+    };
+    /** Exact Yield Copilot discovery identity that may receive this execution ID. */
+    readonly discoveryMarketId: string;
+}
+export type ExecutableYieldMarket = (ExecutableYieldMarketBase & {
+    readonly protocol: 'AAVE';
+    readonly builder: 'aave-native';
+    readonly selectors: {
+        readonly approve: `0x${string}`;
+        readonly supply: `0x${string}`;
+        readonly withdraw: `0x${string}`;
+    };
+}) | (ExecutableYieldMarketBase & {
+    readonly protocol: 'MORPHO';
+    readonly builder: 'morpho-native';
+    /** Pinned ERC-4626 share-token decimals for exact `redeem(max)` accounting. */
+    readonly vaultShareDecimals: 18;
+    readonly selectors: {
+        readonly approve: `0x${string}`;
+        readonly deposit: `0x${string}`;
+        readonly withdraw: `0x${string}`;
+        readonly redeem: `0x${string}`;
+    };
+});
+export declare const BASE_USDC_AAVE_V3_MARKET: {
+    readonly id: "base-usdc-aave-v3";
+    readonly venue: "AAVE V3";
+    readonly protocol: "AAVE";
+    readonly chainId: 8453;
+    readonly chainSlug: "base";
+    readonly asset: {
+        readonly symbol: "USDC";
+        readonly group: "USDC";
+        readonly address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+        readonly decimals: 6;
+    };
+    readonly protocolTarget: "0xA238Dd80C259a72e81d7e4664a9801593F98d1c5";
+    readonly vaultAddress: "0xA238Dd80C259a72e81d7e4664a9801593F98d1c5";
+    readonly nativeValue: "0";
+    readonly builder: "aave-native";
+    readonly selectors: {
+        readonly approve: "0x095ea7b3";
+        readonly supply: "0x617ba037";
+        readonly withdraw: "0x69328dec";
+    };
+    readonly allowedCallSequences: {
+        readonly deposit: readonly [readonly ["approve", "supply"], readonly ["supply"]];
+        readonly withdraw: readonly [readonly ["withdraw"]];
+    };
+    readonly safeBinding: {
+        readonly executionOwner: "SAFE";
+        readonly depositReceiver: "SAFE";
+        readonly withdrawReceiver: "SAFE";
+    };
+    readonly discoveryMarketId: "aave:8453:0xa238dd80c259a72e81d7e4664a9801593f98d1c5:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+};
+export declare const BASE_USDC_MORPHO_GAUNTLET_PRIME_MARKET: {
+    readonly id: "base-usdc-morpho-gauntlet-prime";
+    readonly venue: "MORPHO · GAUNTLET USDC PRIME";
+    readonly protocol: "MORPHO";
+    readonly chainId: 8453;
+    readonly chainSlug: "base";
+    readonly asset: {
+        readonly symbol: "USDC";
+        readonly group: "USDC";
+        readonly address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+        readonly decimals: 6;
+    };
+    readonly protocolTarget: "0xeE8F4eC5672F09119b96Ab6fB59C27E1b7e44b61";
+    readonly vaultAddress: "0xeE8F4eC5672F09119b96Ab6fB59C27E1b7e44b61";
+    readonly vaultShareDecimals: 18;
+    readonly nativeValue: "0";
+    readonly builder: "morpho-native";
+    readonly selectors: {
+        readonly approve: "0x095ea7b3";
+        readonly deposit: "0x6e553f65";
+        readonly withdraw: "0xb460af94";
+        readonly redeem: "0xba087652";
+    };
+    readonly allowedCallSequences: {
+        readonly deposit: readonly [readonly ["approve", "deposit"], readonly ["deposit"]];
+        readonly withdraw: readonly [readonly ["withdraw"], readonly ["redeem"]];
+    };
+    readonly safeBinding: {
+        readonly executionOwner: "SAFE";
+        readonly depositReceiver: "SAFE";
+        readonly withdrawReceiver: "SAFE";
+    };
+    readonly discoveryMarketId: "morpho:8453:0xee8f4ec5672f09119b96ab6fb59c27e1b7e44b61:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+};
+export declare const BASE_USDC_MORPHO_STEAKHOUSE_PRIME_MARKET: {
+    readonly id: "base-usdc-morpho-steakhouse-prime";
+    readonly venue: "MORPHO · STEAKHOUSE PRIME USDC";
+    readonly protocol: "MORPHO";
+    readonly chainId: 8453;
+    readonly chainSlug: "base";
+    readonly asset: {
+        readonly symbol: "USDC";
+        readonly group: "USDC";
+        readonly address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+        readonly decimals: 6;
+    };
+    readonly protocolTarget: "0xBEEFE94c8aD530842bfE7d8B397938fFc1cb83b2";
+    readonly vaultAddress: "0xBEEFE94c8aD530842bfE7d8B397938fFc1cb83b2";
+    readonly vaultShareDecimals: 18;
+    readonly nativeValue: "0";
+    readonly builder: "morpho-native";
+    readonly selectors: {
+        readonly approve: "0x095ea7b3";
+        readonly deposit: "0x6e553f65";
+        readonly withdraw: "0xb460af94";
+        readonly redeem: "0xba087652";
+    };
+    readonly allowedCallSequences: {
+        readonly deposit: readonly [readonly ["approve", "deposit"], readonly ["deposit"]];
+        readonly withdraw: readonly [readonly ["withdraw"], readonly ["redeem"]];
+    };
+    readonly safeBinding: {
+        readonly executionOwner: "SAFE";
+        readonly depositReceiver: "SAFE";
+        readonly withdrawReceiver: "SAFE";
+    };
+    readonly discoveryMarketId: "morpho:8453:0xbeefe94c8ad530842bfe7d8b397938ffc1cb83b2:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+};
+export declare const EXECUTABLE_YIELD_MARKETS: readonly [{
+    readonly id: "base-usdc-aave-v3";
+    readonly venue: "AAVE V3";
+    readonly protocol: "AAVE";
+    readonly chainId: 8453;
+    readonly chainSlug: "base";
+    readonly asset: {
+        readonly symbol: "USDC";
+        readonly group: "USDC";
+        readonly address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+        readonly decimals: 6;
+    };
+    readonly protocolTarget: "0xA238Dd80C259a72e81d7e4664a9801593F98d1c5";
+    readonly vaultAddress: "0xA238Dd80C259a72e81d7e4664a9801593F98d1c5";
+    readonly nativeValue: "0";
+    readonly builder: "aave-native";
+    readonly selectors: {
+        readonly approve: "0x095ea7b3";
+        readonly supply: "0x617ba037";
+        readonly withdraw: "0x69328dec";
+    };
+    readonly allowedCallSequences: {
+        readonly deposit: readonly [readonly ["approve", "supply"], readonly ["supply"]];
+        readonly withdraw: readonly [readonly ["withdraw"]];
+    };
+    readonly safeBinding: {
+        readonly executionOwner: "SAFE";
+        readonly depositReceiver: "SAFE";
+        readonly withdrawReceiver: "SAFE";
+    };
+    readonly discoveryMarketId: "aave:8453:0xa238dd80c259a72e81d7e4664a9801593f98d1c5:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+}, {
+    readonly id: "base-usdc-morpho-gauntlet-prime";
+    readonly venue: "MORPHO · GAUNTLET USDC PRIME";
+    readonly protocol: "MORPHO";
+    readonly chainId: 8453;
+    readonly chainSlug: "base";
+    readonly asset: {
+        readonly symbol: "USDC";
+        readonly group: "USDC";
+        readonly address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+        readonly decimals: 6;
+    };
+    readonly protocolTarget: "0xeE8F4eC5672F09119b96Ab6fB59C27E1b7e44b61";
+    readonly vaultAddress: "0xeE8F4eC5672F09119b96Ab6fB59C27E1b7e44b61";
+    readonly vaultShareDecimals: 18;
+    readonly nativeValue: "0";
+    readonly builder: "morpho-native";
+    readonly selectors: {
+        readonly approve: "0x095ea7b3";
+        readonly deposit: "0x6e553f65";
+        readonly withdraw: "0xb460af94";
+        readonly redeem: "0xba087652";
+    };
+    readonly allowedCallSequences: {
+        readonly deposit: readonly [readonly ["approve", "deposit"], readonly ["deposit"]];
+        readonly withdraw: readonly [readonly ["withdraw"], readonly ["redeem"]];
+    };
+    readonly safeBinding: {
+        readonly executionOwner: "SAFE";
+        readonly depositReceiver: "SAFE";
+        readonly withdrawReceiver: "SAFE";
+    };
+    readonly discoveryMarketId: "morpho:8453:0xee8f4ec5672f09119b96ab6fb59c27e1b7e44b61:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+}, {
+    readonly id: "base-usdc-morpho-steakhouse-prime";
+    readonly venue: "MORPHO · STEAKHOUSE PRIME USDC";
+    readonly protocol: "MORPHO";
+    readonly chainId: 8453;
+    readonly chainSlug: "base";
+    readonly asset: {
+        readonly symbol: "USDC";
+        readonly group: "USDC";
+        readonly address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+        readonly decimals: 6;
+    };
+    readonly protocolTarget: "0xBEEFE94c8aD530842bfE7d8B397938fFc1cb83b2";
+    readonly vaultAddress: "0xBEEFE94c8aD530842bfE7d8B397938fFc1cb83b2";
+    readonly vaultShareDecimals: 18;
+    readonly nativeValue: "0";
+    readonly builder: "morpho-native";
+    readonly selectors: {
+        readonly approve: "0x095ea7b3";
+        readonly deposit: "0x6e553f65";
+        readonly withdraw: "0xb460af94";
+        readonly redeem: "0xba087652";
+    };
+    readonly allowedCallSequences: {
+        readonly deposit: readonly [readonly ["approve", "deposit"], readonly ["deposit"]];
+        readonly withdraw: readonly [readonly ["withdraw"], readonly ["redeem"]];
+    };
+    readonly safeBinding: {
+        readonly executionOwner: "SAFE";
+        readonly depositReceiver: "SAFE";
+        readonly withdrawReceiver: "SAFE";
+    };
+    readonly discoveryMarketId: "morpho:8453:0xbeefe94c8ad530842bfe7d8b397938ffc1cb83b2:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+}];
+export type ExecutableYieldMarketId = (typeof EXECUTABLE_YIELD_MARKETS)[number]['id'];
+export type ExecutableYieldMarketCommitment = `sha256:${string}`;
+/** SHA-256 commitment over every enumerable field in the complete, canonical registry record. */
+export declare function getExecutableYieldMarketCommitment(market: ExecutableYieldMarket): ExecutableYieldMarketCommitment;
+export declare function getExecutableYieldMarket(marketId: string): ExecutableYieldMarket | null;
+export {};