otto-intel-mcp 0.1.2 → 0.1.4

package/dist/hybrid-yield.d.ts

@@ -0,0 +1,411 @@
+/**
+ * One hybrid decision/prepare contract. A routed funding leg is never described
+ * as a completed yield position, and a gated native choice never silently falls
+ * back to a more expensive routed share purchase.
+ */
+import { z } from 'zod';
+import { type ExecutionToolRuntime } from './execution-tools.js';
+import { type NativeYieldRuntime } from './native-yield.js';
+export declare const PREPARE_HYBRID_YIELD_INPUT_SCHEMA: z.ZodObject<{
+    accountProfile: z.ZodObject<{
+        kind: z.ZodLiteral<"eoa">;
+        address: z.ZodString;
+        chainId: z.ZodUnion<readonly [z.ZodLiteral<8453>, z.ZodLiteral<42161>]>;
+    }, z.core.$strict>;
+    marketId: z.ZodString;
+    registryCommitment: z.ZodString;
+    action: z.ZodEnum<{
+        deposit: "deposit";
+        withdraw: "withdraw";
+    }>;
+    amount: z.ZodString;
+    sourceToken: z.ZodString;
+    transport: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        lifi: "lifi";
+        native: "native";
+    }>>;
+    slippage: z.ZodObject<{
+        maxBps: z.ZodNumber;
+        minOutput: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    fundingMinimumOutput: z.ZodOptional<z.ZodString>;
+    clientRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PrepareHybridYieldInput = z.infer<typeof PREPARE_HYBRID_YIELD_INPUT_SCHEMA>;
+export interface HybridYieldRuntime {
+    readonly lifi: ExecutionToolRuntime;
+    readonly native: NativeYieldRuntime;
+}
+export declare function selectHybridYieldTransport(rawInput: unknown): {
+    input: {
+        accountProfile: {
+            kind: "eoa";
+            address: string;
+            chainId: 8453 | 42161;
+        };
+        marketId: string;
+        registryCommitment: string;
+        action: "deposit" | "withdraw";
+        amount: string;
+        sourceToken: string;
+        transport: "auto" | "lifi" | "native";
+        slippage: {
+            maxBps: number;
+            minOutput?: string | undefined;
+        };
+        fundingMinimumOutput?: string | undefined;
+        clientRef?: string | undefined;
+    };
+    market: import("./hybrid-yield-markets.js").HybridYieldMarket;
+    source: `0x${string}`;
+    transport: "lifi" | "native";
+    stage: string;
+};
+export declare function prepareHybridYield(runtime: HybridYieldRuntime, rawInput: unknown, signal?: AbortSignal): Promise<{
+    stage: string;
+    binding: {
+        marketId: string;
+        registryCommitment: string;
+        requestCommitment: `sha256:${string}`;
+        owner: `0x${string}`;
+        positionChainId: import("./hybrid-yield-markets.js").HybridYieldChainId;
+        positionToken: `0x${string}`;
+    };
+    plan: {
+        schemaVersion: "1";
+        kind: "native-yield-plan";
+        transport: "native-protocol";
+        marketId: string;
+        registryCommitment: string;
+        owner: string;
+        chainId: 8453 | 42161;
+        action: "deposit" | "withdraw";
+        amount: string;
+        inputToken: string;
+        outputToken: string;
+        expectedOutput: string;
+        minimumOutput: string;
+        protocolOutput: string;
+        fee: {
+            bps: 10;
+            recipient: string;
+            token: string;
+            amount: string;
+            version: "native-yield-10bps-floor-v1";
+            rounding: "floor";
+        };
+        nonce: string;
+        deadline: number;
+        preparedAtMs: number;
+        snapshot: {
+            blockNumber: string;
+            blockHash: string;
+            observedAtMs: number;
+        };
+        deployment: {
+            chainId: 8453 | 42161;
+            address: string;
+            runtimeCodeHash: string;
+            version: "native-yield-router-v1";
+            reviewId: string;
+        };
+        steps: {
+            kind: "approve" | "approve_reset" | "call";
+            to: string;
+            value: "0";
+            data: string;
+        }[];
+        authorization: "requires-separate-account-authority";
+        allowanceRecovery: "approval-is-separate-and-may-remain-after-failure";
+        intentCommitment: string;
+        planCommitment: string;
+    };
+    completionRequirement: "canonical-protocol-event-and-owner-receipt";
+} | {
+    stage: string;
+    binding: {
+        marketId: string;
+        registryCommitment: string;
+        requestCommitment: `sha256:${string}`;
+        owner: `0x${string}`;
+        positionChainId: import("./hybrid-yield-markets.js").HybridYieldChainId;
+        positionToken: `0x${string}`;
+    };
+    prepared: {
+        envelope: {
+            schema_version: "1";
+            artifact_id: string;
+            rail: "lifi";
+            operation: "swap";
+            intent_digest: string;
+            account_binding: {
+                kind: "eoa" | "safe";
+                address: string;
+                chainId: number;
+                protocol_roles: {
+                    lifi: {
+                        sender: string;
+                        receiver: string;
+                    };
+                };
+            };
+            required_capabilities: ("send_evm_transaction" | "submit_evm_batch")[];
+            payload: {
+                kind: "evm_execution_plan";
+                chain_id: number;
+                steps: {
+                    to: string;
+                    value: string;
+                    data: string;
+                    kind: "approve" | "approve_reset" | "call";
+                }[];
+            };
+            fee_attribution: {
+                mechanism: "lifi_integrator_fee";
+                config_version: string;
+            };
+            replay_disclosure: {
+                artifact_role: "construction_aid";
+                freshness_boundary: "valid_until";
+                onchain_replay_boundary: "signer_account_nonce";
+                tool_guarantees_single_execution: false;
+            };
+            assertions: {
+                id: string;
+                result: "passed";
+            }[];
+            valid_until: string;
+            submission: {
+                method: "send_evm_transaction" | "submit_evm_batch";
+                chain_id: number;
+                artifact_id: string;
+                payload_digest: string;
+                artifact_digest: string;
+                adapter_owned_fields: ["nonce", "gas", "serialization"];
+                client_ref?: string | undefined;
+            };
+        };
+        prepareInput: {
+            accountProfile: {
+                kind: "eoa" | "safe";
+                address: string;
+                chainId: number;
+            };
+            chainId: number;
+            fromToken: string;
+            toToken: string;
+            fromAmount: string;
+            slippage: {
+                maxBps: number;
+                minAmountOut?: string | undefined;
+            };
+            client_ref?: string | undefined;
+        };
+        preview: {
+            market_id: string;
+            venue: string;
+            protocol: "MORPHO";
+            chain_id: 8453;
+            vault: string;
+            asset: string;
+            shares: string;
+            expected_assets: string;
+            min_assets: string;
+            preview_redeem_assets: string;
+            parity_shortfall_bps: number;
+            parity_tolerance_bps: 30;
+            quoted_fees: {
+                name: string;
+                amount_usd: string;
+            }[];
+            route_semantics: {
+                transport: "lifi";
+                action: "deposit" | "withdraw";
+                classification: "share-purchase" | "share-sale" | "protocol-composition" | "mixed" | "unclassified";
+                evidence: "provider-quote-steps";
+                protocol_action_verified: false;
+                tools: string[];
+            };
+            quoted_gas_usd?: string | undefined;
+        };
+        registry_commitment: string;
+    } | {
+        envelope: {
+            schema_version: "1";
+            artifact_id: string;
+            rail: "lifi";
+            operation: "swap";
+            intent_digest: string;
+            account_binding: {
+                kind: "eoa" | "safe";
+                address: string;
+                chainId: number;
+                protocol_roles: {
+                    lifi: {
+                        sender: string;
+                        receiver: string;
+                    };
+                };
+            };
+            required_capabilities: ("send_evm_transaction" | "submit_evm_batch")[];
+            payload: {
+                kind: "evm_execution_plan";
+                chain_id: number;
+                steps: {
+                    to: string;
+                    value: string;
+                    data: string;
+                    kind: "approve" | "approve_reset" | "call";
+                }[];
+            };
+            fee_attribution: {
+                mechanism: "lifi_integrator_fee";
+                config_version: string;
+            };
+            replay_disclosure: {
+                artifact_role: "construction_aid";
+                freshness_boundary: "valid_until";
+                onchain_replay_boundary: "signer_account_nonce";
+                tool_guarantees_single_execution: false;
+            };
+            assertions: {
+                id: string;
+                result: "passed";
+            }[];
+            valid_until: string;
+            submission: {
+                method: "send_evm_transaction" | "submit_evm_batch";
+                chain_id: number;
+                artifact_id: string;
+                payload_digest: string;
+                artifact_digest: string;
+                adapter_owned_fields: ["nonce", "gas", "serialization"];
+                client_ref?: string | undefined;
+            };
+        };
+        prepareInput: {
+            accountProfile: {
+                kind: "eoa" | "safe";
+                address: string;
+                chainId: number;
+            };
+            chainId: number;
+            fromToken: string;
+            toToken: string;
+            fromAmount: string;
+            slippage: {
+                maxBps: number;
+                minAmountOut?: string | undefined;
+            };
+            client_ref?: string | undefined;
+        };
+        preview: {
+            market_id: string;
+            venue: string;
+            protocol: "MORPHO";
+            chain_id: 8453;
+            vault: string;
+            asset: string;
+            amount: string;
+            expected_shares: string;
+            min_shares: string;
+            preview_deposit_shares: string;
+            parity_shortfall_bps: number;
+            parity_tolerance_bps: 30;
+            quoted_fees: {
+                name: string;
+                amount_usd: string;
+            }[];
+            route_semantics: {
+                transport: "lifi";
+                action: "deposit" | "withdraw";
+                classification: "share-purchase" | "share-sale" | "protocol-composition" | "mixed" | "unclassified";
+                evidence: "provider-quote-steps";
+                protocol_action_verified: false;
+                tools: string[];
+            };
+            quoted_gas_usd?: string | undefined;
+        };
+        registry_commitment: string;
+    };
+    completionRequirement: "canonical-owner-token-receipt-protocol-action-unproven-until-verified";
+} | {
+    stage: string;
+    binding: {
+        marketId: string;
+        registryCommitment: string;
+        requestCommitment: `sha256:${string}`;
+        owner: `0x${string}`;
+        positionChainId: import("./hybrid-yield-markets.js").HybridYieldChainId;
+        positionToken: `0x${string}`;
+    };
+    prepareInput: {
+        accountProfile: {
+            kind: "eoa" | "safe";
+            address: string;
+            chainId: number;
+        };
+        chainId: number;
+        fromToken: string;
+        toToken: string;
+        fromAmount: string;
+        slippage: {
+            maxBps: number;
+            minAmountOut?: string | undefined;
+        };
+        client_ref?: string | undefined;
+    };
+    envelope: import("./execution-types.js").ExecutionEnvelope;
+    continuation: {
+        action: "prepare-new-native-deposit-after-settlement";
+        automatic: false;
+        marketId: string;
+        registryCommitment: string;
+        chainId: import("./hybrid-yield-markets.js").HybridYieldChainId;
+        asset: `0x${string}`;
+        owner: `0x${string}`;
+    };
+    completionRequirement: "underlying-receipt-only-not-yield-allocation";
+} | {
+    stage: string;
+    binding: {
+        marketId: string;
+        registryCommitment: string;
+        requestCommitment: `sha256:${string}`;
+        owner: `0x${string}`;
+        positionChainId: import("./hybrid-yield-markets.js").HybridYieldChainId;
+        positionToken: `0x${string}`;
+    };
+    prepareInput: {
+        accountProfile: {
+            kind: "eoa" | "safe";
+            address: string;
+            chainId: number;
+        };
+        fromChainId: number;
+        toChainId: number;
+        fromToken: string;
+        toToken: string;
+        fromAmount: string;
+        slippage: {
+            maxBps: number;
+            minAmountOut?: string | undefined;
+        };
+        destinationRecipient?: string | undefined;
+        client_ref?: string | undefined;
+    };
+    envelope: import("./execution-types.js").BridgeExecutionEnvelope;
+    continuation: {
+        action: "prepare-new-native-deposit-after-settlement";
+        automatic: false;
+        marketId: string;
+        registryCommitment: string;
+        chainId: import("./hybrid-yield-markets.js").HybridYieldChainId;
+        asset: `0x${string}`;
+        owner: `0x${string}`;
+    };
+    completionRequirement: "completed-bridge-and-actual-underlying-receipt-not-yield-allocation";
+}>;
+/** LI.FI status labels alone never establish an earning position or actual amount. */
+export declare function hybridFundingOutcome(status: string, substatus: string | undefined): "needs-attention" | "verify-destination-underlying" | "funds-on-destination-needs-attention" | "verify-refund-no-allocation" | "pending-or-unknown-do-not-resubmit";

package/dist/hybrid-yield.js

@@ -0,0 +1,155 @@
+/**
+ * One hybrid decision/prepare contract. A routed funding leg is never described
+ * as a completed yield position, and a gated native choice never silently falls
+ * back to a more expensive routed share purchase.
+ */
+import { z } from 'zod';
+import { getAddress } from 'viem';
+import { HYBRID_YIELD_MARKETS, freezeHybridValue, getHybridYieldMarket, hybridYieldCommitment } from './hybrid-yield-markets.js';
+import { PREPARE_BRIDGE_INPUT_SCHEMA, PREPARE_SWAP_INPUT_SCHEMA } from './execution-tool-definitions.js';
+import { prepareBridge, prepareSwapFromQuote, quoteSwap } from './execution-tools.js';
+import { prepareYieldDeposit } from './yield-deposit.js';
+import { prepareYieldWithdraw } from './yield-withdraw.js';
+import { prepareNativeYield } from './native-yield.js';
+import { refuseNative } from './native-yield-definition.js';
+const positive = z.string().regex(/^[1-9]\d*$/).refine((v) => BigInt(v) < (1n << 256n));
+export const PREPARE_HYBRID_YIELD_INPUT_SCHEMA = z.object({
+    accountProfile: z.object({
+        kind: z.literal('eoa'), address: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
+        chainId: z.union([z.literal(8453), z.literal(42161)]),
+    }).strict(),
+    marketId: z.string().min(1).max(120),
+    registryCommitment: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+    action: z.enum(['deposit', 'withdraw']),
+    amount: positive,
+    sourceToken: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
+    transport: z.enum(['auto', 'native', 'lifi']).default('auto'),
+    slippage: z.object({ maxBps: z.number().int().min(1).max(100), minOutput: positive.optional() }).strict(),
+    /** Underlying units at destination, only for a separate swap/bridge funding leg. */
+    fundingMinimumOutput: positive.optional(),
+    clientRef: z.string().trim().min(1).max(128).optional(),
+}).strict();
+export function selectHybridYieldTransport(rawInput) {
+    const input = PREPARE_HYBRID_YIELD_INPUT_SCHEMA.parse(rawInput);
+    const market = getHybridYieldMarket(input.marketId);
+    if (!market || hybridYieldCommitment(market) !== input.registryCommitment) {
+        return refuseNative('HYBRID_MARKET_MISMATCH', 'Re-read the exact current hybrid market');
+    }
+    const source = getAddress(input.sourceToken);
+    const sameChain = input.accountProfile.chainId === market.chainId;
+    if (input.action === 'withdraw') {
+        if (!sameChain || source !== market.position.tokenAddress) {
+            return refuseNative('HYBRID_EXIT_BINDING', 'Exit the exact position token on its owning chain');
+        }
+    }
+    else {
+        if (market.curation.status === 'legacy-exit-only') {
+            return refuseNative('HYBRID_LEGACY_DEPOSIT', 'This legacy vault is retained for exit; select a current candidate for new allocation');
+        }
+        if (!HYBRID_YIELD_MARKETS.some((m) => m.chainId === input.accountProfile.chainId && m.asset.address === source)) {
+            return refuseNative('HYBRID_SOURCE_UNSUPPORTED', 'Source must be exact reviewed USDC or WETH on Base or Arbitrum');
+        }
+    }
+    const exactAsset = sameChain && source === market.asset.address;
+    const nativeEligible = input.action === 'withdraw' || exactAsset;
+    if (input.transport === 'native' && !nativeEligible) {
+        return refuseNative('HYBRID_NATIVE_REQUIRES_EXACT_ASSET', 'Swap or bridge into the exact deposit asset first');
+    }
+    const transport = input.transport === 'auto' ? (nativeEligible ? 'native' : 'lifi') : input.transport;
+    const stage = transport === 'native' ? 'native-position'
+        : market.legacyRegistryCommitment && sameChain && (input.action === 'withdraw' || exactAsset)
+            ? 'routed-position' : 'routed-funding';
+    if (stage === 'routed-funding' && (input.action !== 'deposit' || exactAsset)) {
+        return refuseNative('HYBRID_ROUTE_UNAVAILABLE', 'No reviewed LI.FI position route exists for this market; use its native capability after activation');
+    }
+    return freezeHybridValue({ input, market, source, transport, stage });
+}
+export async function prepareHybridYield(runtime, rawInput, signal) {
+    const selected = selectHybridYieldTransport(rawInput);
+    const { input, market, source, stage } = selected;
+    const binding = {
+        marketId: market.id, registryCommitment: input.registryCommitment,
+        requestCommitment: hybridYieldCommitment(input), owner: getAddress(input.accountProfile.address),
+        positionChainId: market.chainId, positionToken: market.position.tokenAddress,
+    };
+    if (stage === 'native-position') {
+        const plan = await prepareNativeYield(runtime.native, {
+            accountProfile: input.accountProfile, marketId: input.marketId,
+            registryCommitment: input.registryCommitment, action: input.action, amount: input.amount,
+            slippage: input.slippage, ...(input.clientRef ? { clientRef: input.clientRef } : {}),
+        });
+        return freezeHybridValue({
+            stage, binding, plan,
+            completionRequirement: 'canonical-protocol-event-and-owner-receipt',
+        });
+    }
+    if (stage === 'routed-position') {
+        const shared = {
+            accountProfile: input.accountProfile, executableMarketId: market.id,
+            registryCommitment: market.legacyRegistryCommitment,
+            slippage: { maxBps: input.slippage.maxBps },
+            ...(input.clientRef ? { client_ref: input.clientRef } : {}),
+        };
+        const prepared = input.action === 'deposit'
+            ? await prepareYieldDeposit(runtime.lifi, { ...shared, amount: input.amount }, signal)
+            : await prepareYieldWithdraw(runtime.lifi, { ...shared, shares: input.amount }, signal);
+        const quotedFloor = BigInt(prepared.prepareInput.slippage.minAmountOut);
+        if (input.slippage.minOutput && quotedFloor < BigInt(input.slippage.minOutput)) {
+            return refuseNative('HYBRID_MINIMUM_INVALID', 'Route minimum is below the reviewed position/exit floor');
+        }
+        return freezeHybridValue({
+            stage, binding, prepared,
+            completionRequirement: 'canonical-owner-token-receipt-protocol-action-unproven-until-verified',
+        });
+    }
+    // The existing bridge verifier explicitly forbids destination calls. Preserve it:
+    // fund the exact underlying, settle, then request a fresh native deposit review.
+    if (!input.fundingMinimumOutput) {
+        return refuseNative('HYBRID_FUNDING_FLOOR_REQUIRED', 'Review a separate minimum in destination underlying units for this funding leg');
+    }
+    const continuation = {
+        action: 'prepare-new-native-deposit-after-settlement',
+        automatic: false, marketId: market.id, registryCommitment: input.registryCommitment,
+        chainId: market.chainId, asset: market.asset.address, owner: binding.owner,
+    };
+    const common = {
+        accountProfile: input.accountProfile, fromToken: source, toToken: market.asset.address,
+        fromAmount: input.amount,
+        slippage: { maxBps: input.slippage.maxBps, minAmountOut: input.fundingMinimumOutput },
+        ...(input.clientRef ? { client_ref: input.clientRef } : {}),
+    };
+    if (input.accountProfile.chainId === market.chainId) {
+        const prepareInput = PREPARE_SWAP_INPUT_SCHEMA.parse({ ...common, chainId: market.chainId });
+        const quote = await quoteSwap(runtime.lifi, prepareInput, signal);
+        const envelope = prepareSwapFromQuote(runtime.lifi, prepareInput, quote);
+        return freezeHybridValue({
+            stage, binding, prepareInput, envelope, continuation,
+            completionRequirement: 'underlying-receipt-only-not-yield-allocation',
+        });
+    }
+    if (market.asset.symbol !== 'USDC') {
+        return refuseNative('HYBRID_CROSS_CHAIN_ASSET_UNSUPPORTED', 'Existing reviewed bridge is native-USDC only; cross-chain WETH is not enabled');
+    }
+    const prepareInput = PREPARE_BRIDGE_INPUT_SCHEMA.parse({
+        ...common, fromChainId: input.accountProfile.chainId, toChainId: market.chainId,
+        destinationRecipient: binding.owner,
+    });
+    const envelope = await prepareBridge(runtime.lifi, prepareInput, signal);
+    return freezeHybridValue({
+        stage, binding, prepareInput, envelope, continuation,
+        completionRequirement: 'completed-bridge-and-actual-underlying-receipt-not-yield-allocation',
+    });
+}
+/** LI.FI status labels alone never establish an earning position or actual amount. */
+export function hybridFundingOutcome(status, substatus) {
+    if (status === 'DONE' && substatus === 'COMPLETED')
+        return 'verify-destination-underlying';
+    if (status === 'DONE' && substatus === 'PARTIAL')
+        return 'funds-on-destination-needs-attention';
+    if (status === 'DONE' && substatus === 'REFUNDED')
+        return 'verify-refund-no-allocation';
+    if (status === 'FAILED')
+        return 'needs-attention';
+    return 'pending-or-unknown-do-not-resubmit';
+}
+//# sourceMappingURL=hybrid-yield.js.map

package/dist/hyperliquid-order-builder.js

@@ -27,6 +27,10 @@ const HYPERLIQUID_ORDER_PARAMETERS = v.omit(v.object(OrderRequest.entries.action
  * action layer: whatever this function returns contains only fields the venue itself declares.
  */
 export function buildUnsignedHyperliquidOrderAction(request) {
+    // A direct SDK import must not bypass the retired high-level constructor.
+    if (request.legs.some((leg) => leg.reduceOnly !== true)) {
+        return refuse('HYPERLIQUID_RETIRED', 'New Hyperliquid trading is retired; every recovery order leg must be reduce-only');
+    }
     if (request.legs.length === 0) {
         return refuse('HYPERLIQUID_ORDER_INVALID', 'Hyperliquid action must carry at least one order leg');
     }

package/dist/lifi-execution-client.d.ts

@@ -39,6 +39,12 @@ export interface SameChainSwapQuoteRequest {
     readonly sender: string;
     readonly receiver: string;
     readonly maxSlippageBps: number;
+    /**
+     * LI.FI exchange tools the quote must NOT route through. Set by the constructor when a tool's
+     * calldata failed the prepare-time simulation (2026-09-03: KyberSwap reverted from the diamond while
+     * SushiSwap executed); never a caller seam.
+     */
+    readonly denyExchanges?: readonly string[];
 }
 export interface CrossChainBridgeQuoteRequest {
     readonly fromChainId: number;

package/dist/lifi-execution-client.js

@@ -65,6 +65,9 @@ export function buildLiFiQuoteUrl(request, config) {
     ];
     for (const [name, value] of semanticFields)
         url.searchParams.append(name, value);
+    if (request.denyExchanges && request.denyExchanges.length > 0) {
+        url.searchParams.append('denyExchanges', request.denyExchanges.join(','));
+    }
     url.searchParams.append('integrator', LIFI_INTEGRATOR);
     url.searchParams.append('fee', config.lifiFee.decimal);
     return url;