otto-intel-mcp 0.1.0

package/dist/execution-tools.d.ts

@@ -0,0 +1,85 @@
+import { type ExecutionServiceConfig } from './execution-config.js';
+import { type DelegationServices } from './execution-delegation.js';
+import { type BridgeExecutionEnvelope, type ExecutionEnvelope, type HyperliquidExecutionEnvelope, type PolymarketExecutionEnvelope } from './execution-types.js';
+import { type HyperliquidInfoClient } from './hyperliquid-info-client.js';
+import { type UnsignedHyperliquidAction, type UnsignedHyperliquidActionRequest } from './hyperliquid-order-builder.js';
+import { type LiFiQuoteClient } from './lifi-execution-client.js';
+import { type PolymarketClobClient } from './polymarket-clob-client.js';
+import { type UnsignedPolymarketOrder, type UnsignedPolymarketOrderRequest } from './polymarket-order-builder.js';
+/** The order-construction seam: request in, unsigned SDK-built order out. */
+export type PolymarketOrderBuilder = (request: UnsignedPolymarketOrderRequest) => Promise<UnsignedPolymarketOrder>;
+/** The Hyperliquid action-construction seam: legs in, venue-normalized canonical action out. */
+export type HyperliquidActionBuilder = (request: UnsignedHyperliquidActionRequest) => UnsignedHyperliquidAction;
+export interface ExecutionToolRuntime {
+    readonly config: ExecutionServiceConfig;
+    readonly quoteClient: LiFiQuoteClient;
+    readonly clobClient: PolymarketClobClient;
+    /**
+     * The Polymarket order-construction seam. Production always uses the SDK-backed builder; it is
+     * injectable so the decode-back assertions can be mutation-proved against a real constructed
+     * order — an assertion no test can redden is indistinguishable from an absent one.
+     */
+    readonly polymarketOrderBuilder: PolymarketOrderBuilder;
+    readonly hyperliquidInfoClient: HyperliquidInfoClient;
+    /** Injectable for the same reason as the Polymarket seam: the decode-back must be mutation-provable. */
+    readonly hyperliquidActionBuilder: HyperliquidActionBuilder;
+    readonly nowMs: () => number;
+    readonly entropy: () => Uint8Array;
+    /**
+     * 16 bytes per Hyperliquid client order id. Separate from `entropy`, which mints the 10-byte ULID
+     * suffix: a shared source would silently hand a 10-byte buffer to a 16-byte field.
+     */
+    readonly clientOrderIdEntropy: () => Uint8Array;
+    /**
+     * The delegated-send services (Otto's CDP developer access + the caller secret), present only on the
+     * hosted service when the five delegation variables are set. The prepare tools never READ it; the swap
+     * constructor records every artifact it mints there, because the delegated tool submits only artifacts
+     * this process prepared (`prepared-artifacts.ts`).
+     */
+    readonly delegation?: DelegationServices;
+}
+export interface ExecutionRuntimeOverrides {
+    readonly quoteClient?: LiFiQuoteClient;
+    readonly clobClient?: PolymarketClobClient;
+    readonly polymarketOrderBuilder?: PolymarketOrderBuilder;
+    readonly hyperliquidInfoClient?: HyperliquidInfoClient;
+    readonly hyperliquidActionBuilder?: HyperliquidActionBuilder;
+    readonly nowMs?: () => number;
+    readonly entropy?: () => Uint8Array;
+    readonly clientOrderIdEntropy?: () => Uint8Array;
+    readonly delegation?: DelegationServices;
+}
+export declare function createExecutionToolRuntime(config: ExecutionServiceConfig, overrides?: ExecutionRuntimeOverrides): ExecutionToolRuntime;
+export declare function createExecutionToolRuntimeFromEnv(env?: NodeJS.ProcessEnv): ExecutionToolRuntime | undefined;
+/**
+ * The hosted boot: the prepare runtime plus, when the five delegation variables are set, the delegated
+ * services (the optional SDK loaded, the Base RPC chain id checked). Delegation configured while
+ * execution is switched off is a misconfiguration and refuses to boot rather than silently dropping
+ * the tool.
+ */
+export declare function createExecutionToolRuntimeWithDelegationFromEnv(env?: NodeJS.ProcessEnv): Promise<ExecutionToolRuntime | undefined>;
+export declare function prepareSwap(runtime: ExecutionToolRuntime, rawInput: unknown, signal?: AbortSignal): Promise<ExecutionEnvelope>;
+/**
+ * Build the ordered source-chain plan for a cross-chain native-USDC bridge over the enumerated v1
+ * Circle-CCTP route set. Prepare-only: the plan is handed to the caller's own custody to sign.
+ */
+export declare function prepareBridge(runtime: ExecutionToolRuntime, rawInput: unknown, signal?: AbortSignal): Promise<BridgeExecutionEnvelope>;
+/**
+ * Build an unsigned Polymarket CTF Exchange V2 limit order for the caller's own Polygon EOA, with
+ * Otto's builder code inside the signed struct (spec §7.3). Prepare-only: the artifact carries order
+ * args and the EIP-712 payload; the caller's own signer signs it and the caller's own credentials
+ * post it. Nothing here holds a key, a CLOB credential, or the caller's collateral.
+ */
+export declare function preparePolymarketOrder(runtime: ExecutionToolRuntime, rawInput: unknown, signal?: AbortSignal): Promise<PolymarketExecutionEnvelope>;
+/**
+ * Build an unsigned Hyperliquid perp order L1 action for the caller's own Hyperliquid account, with
+ * optional reduce-only take-profit and stop-loss triggers bundled under `normalTpsl` (spec §7.2).
+ *
+ * Prepare-only, and structurally so: nothing on this path can sign or submit. The artifact carries the
+ * canonical action plus the declared EIP-712 Agent domain, struct, and `connectionId` recipe; the
+ * caller's own signer picks the nonce, computes the digest, and signs. The root-secret-derived agent
+ * wallet the trade-execution agent uses (`hyperliquid-client.ts:558`) is fenced out entirely (§11), and
+ * the builder attribution field is spec'd and VALUELESS until the Step-0 `approveBuilderFee` reversal
+ * lands (§7.2), so the action carries no builder key and the envelope declares that pending state.
+ */
+export declare function preparePerpOrder(runtime: ExecutionToolRuntime, rawInput: unknown, signal?: AbortSignal): Promise<HyperliquidExecutionEnvelope>;