otto-execute 0.1.0

package/dist/vendor/otto-intel-mcp/execution-config.d.ts

@@ -0,0 +1,232 @@
+import { type Address, type Hex } from 'viem';
+export declare const LIFI_INTEGRATOR: "ottowallet";
+export declare const DEFAULT_LIFI_FEE_BPS: 10;
+export declare const DEFAULT_LIFI_AGGREGATE_FEE_CAP_RATE = "0.0025";
+export declare const DEFAULT_LIFI_FEE_CONFIG_VERSION = "lifi-2026-08-16-10bps-25bps-cap-v2";
+export declare const DEFAULT_OTTO_LIFI_FEE_RECIPIENT: `0x${string}`;
+export declare const DEFAULT_LIFI_PLATFORM_FEE_RECIPIENT: `0x${string}`;
+export declare const LIFI_DIAMOND_ADDRESS: `0x${string}`;
+/**
+ * Reviewed LI.FI FeeForwarder deployments, per chain, as a LIST — every address a fee-forwarding leg
+ * may call. Newest last. A leg calling any address NOT in its chain's list is refused by name (the
+ * drift alarm below), never accepted by shape.
+ *
+ * Review record (both entries verified against lifinance/contracts `deployments/<chain>.json` and
+ * on-chain `eth_getCode`; the v2 rollout is what turned the 2026-08-17 constructors inert until this
+ * list existed — caught 2026-08-26 by the Model-B proof kit's first dry run; that kit's runbook,
+ * `docs/0826_model_b_proof_runbook.md`, ships with the kit and records the finding):
+ *   - v1  `0xC18D…75e1` (56/137/8453/42161/43114) · `0x6855…E4eD` (1) — reviewed 2026-08-16/17;
+ *     still deployed (3110 bytes on Base), no longer emitted by li.quest.
+ *   - v2.0.0 `0xCE40449B773a3E6E5e769ADb4e567179d4828cbd` on ALL six chains — rolled out
+ *     2026-08-21 (lifinance/contracts commit 15039b88 "roll out FeeForwarder v2.0.0 to production
+ *     (EXSC-737) (#2226)"), `src/Periphery/FeeForwarder.sol` `@custom:version 2.0.0`; 3037 bytes,
+ *     byte-identical on Base and Arbitrum (CREATE2); same `collectTokenFees` selector; live legs
+ *     carry unchanged distributions (LI.FI platform + Otto). Reviewed 2026-08-26.
+ *
+ * Adding a deployment here is a REVIEW, not a config edit: confirm the registry entry, read the
+ * bytecode, decode one live leg's distributions, then add — never widen to a pattern.
+ */
+export declare const LIFI_FEE_FORWARDER_V1_MAINNET: `0x${string}`;
+export declare const LIFI_FEE_FORWARDER_V1: `0x${string}`;
+export declare const LIFI_FEE_FORWARDER_V2: `0x${string}`;
+export declare const LIFI_FEE_FORWARDERS_BY_CHAIN: Readonly<Record<number, readonly Address[]>>;
+/** The reviewed FeeForwarder list for a chain, or undefined when the chain is outside the reviewed set. */
+export declare function reviewedLiFiFeeForwarders(chainId: number): readonly Address[] | undefined;
+export declare function isReviewedLiFiFeeForwarder(chainId: number, address: Address): boolean;
+/**
+ * The drift alarm. When a fee-forwarding leg calls a contract that is not on the reviewed list, the
+ * refusal must say so BY ADDRESS and point at where to review it — a silent refusal here is how a
+ * shipped rail goes dark for days after an upstream rollout.
+ */
+export declare function unreviewedFeeForwarderMessage(chainId: number, callTo: Address, approveTo: Address): string;
+/**
+ * The v1 cross-chain bridge route set, ENUMERATED — not "all LI.FI routes" (spec §7.1). The bridge
+ * validator is PolymerCCTP-specific, so a route is supported only when both legs are native Circle
+ * USDC on a chain that (a) carries a reviewed LI.FI FeeForwarder above and (b) was live-verified on
+ * 2026-08-17 to return the reviewed PolymerCCTP facet under `allowBridges=polymerStandard`. All 20
+ * ordered pairs of these five chains were probed and returned selector 0x17917a4e.
+ *
+ * BSC (56) has a reviewed FeeForwarder but is deliberately absent: it carries only Binance-Peg USDC
+ * (18 decimals), not native Circle USDC, so CCTP's burn-and-mint same-token guarantee does not hold.
+ * A request naming any chain outside this table is refused by name — the route is the named defect.
+ */
+export declare const LIFI_CCTP_USDC_BY_CHAIN: Readonly<Record<number, Address>>;
+/** LI.FI bridge tool key pinned in the quote request so the reviewed facet is the only one quoted. */
+export declare const LIFI_POLYMER_BRIDGE_TOOL: "polymerStandard";
+/**
+ * True only for an ordered chain pair inside the enumerated set whose tokens are the pinned native
+ * USDC on each side. Same-token by construction: CCTP burns USDC on the source and mints canonical
+ * USDC on the destination, which is what makes the destination asset assertable from source calldata.
+ */
+export declare function isEnumeratedCctpBridgeRoute(fromChainId: number, toChainId: number, fromToken: Address, toToken: Address): boolean;
+/** The only chain Polymarket's CTF exchanges are deployed on; also the EIP-712 domain chain id. */
+export declare const POLYMARKET_CHAIN_ID: 137;
+/** Collateral and conditional-token atomic precision; mirrors the SDK's COLLATERAL_TOKEN_DECIMALS. */
+export declare const POLYMARKET_AMOUNT_DECIMALS: 6;
+/**
+ * Otto's registered Polymarket builder code, the bytes32 that lands in the `builder` field INSIDE
+ * the signed EIP-712 order (spec §4). Same value the prediction-markets agent already stamps
+ * (`services/prediction-markets-agent/src/lib/polymarket-contracts.ts`), live-verified 2026-08-17
+ * against `GET https://clob.polymarket.com/fees/builder-fees/<code>`: registered, `enabled: true`,
+ * both rates 0 bps.
+ */
+export declare const OTTO_PM_BUILDER_CODE: "0x910082696e647acd3f9486c1a6366840c780a26db5b6aa781892ebf69c48508c";
+export declare const PM_BYTES32_ZERO: `0x${string}`;
+/**
+ * RULED builder-attribution values: 0 bps maker, 0 bps taker (`docs/0808_model_b_scope_and_verdict.md`
+ * §0.3 — "registered and enabled, with both fee rates at 0 bps"; spec §8 records PM as 0/0 today).
+ *
+ * The *flip* to a non-zero taker rate is an OPEN Founder item (spec §13, waits on the
+ * `/builder/trades` volume pull) and is a Polymarket UI settings change, not a code change. So the
+ * constructor never guesses a rate: it stamps the ruled value under a config version and refuses
+ * with `POLYMARKET_BUILDER_FEE_UNRULED` when the live registry no longer matches it. Bumping this
+ * constant plus the config version below is the one place a ruled flip lands.
+ */
+export declare const PM_RULED_BUILDER_FEE_BPS: Readonly<{
+    maker: number;
+    taker: number;
+}>;
+export declare const DEFAULT_PM_BUILDER_FEE_CONFIG_VERSION = "pm-2026-08-17-builder-0bps-0bps-v1";
+export declare const POLYMARKET_TICK_SIZES: readonly ["0.1", "0.01", "0.001", "0.0001"];
+export type PolymarketTickSize = (typeof POLYMARKET_TICK_SIZES)[number];
+export interface PolymarketRounding {
+    readonly price: number;
+    readonly size: number;
+    readonly amount: number;
+}
+/**
+ * Decimal precision the SDK rounds price, size, and derived amounts to, per tick size. The SDK's own
+ * `ROUNDING_CONFIG` is not reachable from the package root, so it is pinned here and *proved* rather
+ * than trusted: the live-captured `polymarket-sdk-created-order-*.json` fixtures are the SDK's real
+ * output for a real market, and the amount assertions run against them.
+ */
+export declare const POLYMARKET_ROUNDING_BY_TICK_SIZE: Readonly<Record<PolymarketTickSize, PolymarketRounding>>;
+export declare function isPolymarketTickSize(value: string): value is PolymarketTickSize;
+export declare const POLYMARKET_EIP712_DOMAIN_NAME: "Polymarket CTF Exchange";
+export declare const POLYMARKET_EIP712_DOMAIN_VERSION: "2";
+export declare const POLYMARKET_ORDER_PRIMARY_TYPE: "Order";
+/**
+ * The CTF Exchange V2 `Order` struct, pinned field-for-field and in order. This is the shape the
+ * user's signer hashes and the exchange re-hashes, so `builder` meaning "builder" depends on this
+ * array being exactly right — a reordered or retyped field silently changes what every other field
+ * commits to. It is asserted against the live-captured SDK payload rather than trusted: the
+ * committed fixtures carry a real signature over a real market, and the recovery check in
+ * `polymarket-order-assertions.ts` fails if this array is off by one entry.
+ *
+ * `expiration` and `taker` are deliberately absent: the V2 exchange does not sign them
+ * (`@polymarket/clob-client-v2` ctfExchangeV2TypedData.js), which is why the artifact carries
+ * `expiration` as an unsigned POST-time field.
+ */
+export declare const POLYMARKET_ORDER_V2_EIP712_FIELDS: readonly {
+    readonly name: string;
+    readonly type: string;
+}[];
+/**
+ * Hyperliquid requires the EIP-712 domain `chainId` of an L1 action to be exactly 1337, regardless
+ * of which EVM chain the signer's wallet is connected to (`@nktkas/hyperliquid` signing/mod.js:175 —
+ * "hyperliquid requires chainId to be 1337"). It is a protocol constant, not a network the artifact
+ * executes on, which is why the account profile must declare it and an adapter re-checks it.
+ */
+export declare const HYPERLIQUID_L1_SIGNATURE_CHAIN_ID: 1337;
+export declare const HYPERLIQUID_EIP712_DOMAIN_NAME: "Exchange";
+export declare const HYPERLIQUID_EIP712_DOMAIN_VERSION: "1";
+export declare const HYPERLIQUID_AGENT_PRIMARY_TYPE: "Agent";
+/** The L1-action domain has no verifying contract; the venue pins the zero address. */
+export declare const HYPERLIQUID_EIP712_VERIFYING_CONTRACT: "0x0000000000000000000000000000000000000000";
+/** `"a"` on mainnet, `"b"` on testnet (signing/mod.js:186). v1 constructs mainnet actions only. */
+export declare const HYPERLIQUID_MAINNET_AGENT_SOURCE: "a";
+/**
+ * The `Agent` struct the user's signer hashes. Pinned field-for-field and in order: the whole action
+ * enters the signature only through `connectionId`, so a reordered or retyped field silently changes
+ * what the signature commits to. Asserted against the SDK's own types in the live-captured fixture.
+ */
+export declare const HYPERLIQUID_AGENT_EIP712_FIELDS: readonly {
+    readonly name: string;
+    readonly type: string;
+}[];
+/**
+ * `connectionId = keccak256(msgpack(action) ++ nonce_u64_be ++ vault_marker[++ vault_address] ++
+ * expires_marker[++ expiresAfter_u64_be])` (`signing/mod.js:88-104`). msgpack encodes object keys in
+ * INSERTION order, so the key order below is part of the signed bytes, not a formatting choice: an
+ * action carrying the same values in a different key order hashes to a different digest and the venue
+ * rejects the signature. The orders below are the exact orders the SDK's own valibot normalizer
+ * emits, live-proved against the captured SDK action in `hyperliquid-fixture-capture.ts`.
+ */
+export declare const HYPERLIQUID_ACTION_KEY_ORDER: readonly string[];
+/** `c` (client order id) is appended only when the order carries one. */
+export declare const HYPERLIQUID_ORDER_KEY_ORDER: readonly string[];
+export declare const HYPERLIQUID_TRIGGER_KEY_ORDER: readonly string[];
+/** Perp price precision ceiling: at most `MAX_DECIMALS - szDecimals` fractional digits. */
+export declare const HYPERLIQUID_PERP_MAX_DECIMALS: 6;
+/** …and at most 5 significant digits, unless the price is an integer (always accepted). */
+export declare const HYPERLIQUID_PRICE_MAX_SIGNIFICANT_DIGITS: 5;
+/**
+ * Venue time-in-force values a caller may name. `FrontendMarket` and `LiquidationMarket` exist in the
+ * venue schema but are Hyperliquid-UI-internal, so they are not offered. A market fill is expressed
+ * as `Ioc` at the caller's OWN aggressive limit price: this constructor never invents a price from a
+ * mark read, which is what the trade-execution agent's market path does (`hyperliquid-client.ts:1785`
+ * — mark × 1.05) and what would let an artifact signed minutes later fill far from the caller's bound.
+ */
+export declare const HYPERLIQUID_TIME_IN_FORCE: readonly ["Gtc", "Ioc", "Alo"];
+export type HyperliquidTimeInForce = (typeof HYPERLIQUID_TIME_IN_FORCE)[number];
+/** `na` for a lone entry; `normalTpsl` binds fixed-size TP/SL legs to the entry (client.ts:1876). */
+export declare const HYPERLIQUID_ORDER_GROUPINGS: readonly ["na", "normalTpsl"];
+export type HyperliquidOrderGrouping = (typeof HYPERLIQUID_ORDER_GROUPINGS)[number];
+/**
+ * RULED builder-attribution state (Founder, 2026-08-17; spec §7.2/§12): the Hyperliquid builder field
+ * is **spec'd and VALUELESS** until the Step-0 `approveBuilderFee` reversal ships. So the constructed
+ * action carries NO `builder` key — an absent key is the only encoding the venue reads as "no builder
+ * fee", and inventing an address or a tenths-of-a-bp value here would stamp an unruled fee inside a
+ * digest the user signs. The exact `{b, f}` assert lands in a follow-up fold; until then the envelope
+ * carries this machine-readable pending marker and the constructor asserts the key's ABSENCE.
+ */
+export declare const HL_BUILDER_ATTRIBUTION_STATUS: "pending_step0_builder_fee_approval";
+export declare const DEFAULT_HL_BUILDER_FEE_CONFIG_VERSION = "hl-2026-08-17-builder-unwired-v1";
+export interface HyperliquidPerpAsset {
+    readonly name: string;
+    /** Index in the live `meta.universe`; the venue's `a` field. Never a value this repo invents. */
+    readonly assetId: number;
+    readonly szDecimals: number;
+    readonly maxLeverage: number;
+    readonly isDelisted: boolean;
+}
+export interface DecimalRate {
+    readonly decimal: string;
+    readonly numerator: bigint;
+    readonly denominator: bigint;
+}
+/**
+ * Prepare-only custody boundary: this runtime never receives or retains caller wallet keys,
+ * signing secrets, or transaction signatures. It may retain an operational LI.FI quote-service
+ * credential, which is isolated from caller schemas and execution envelopes.
+ */
+export interface ExecutionServiceConfig {
+    readonly artifactTtlMs: number;
+    /** Quote-service authentication only; never caller wallet/signing material or envelope data. */
+    readonly lifiApiKey?: string;
+    readonly lifiBaseUrl: string;
+    readonly lifiAggregateFeeCap: DecimalRate;
+    readonly lifiAllowedFeeRecipients: readonly Address[];
+    readonly lifiFee: DecimalRate;
+    readonly lifiFeeConfigVersion: string;
+    readonly lifiFeeRecipient: Address;
+    readonly lifiTimeoutMs: number;
+    readonly polymarketClobBaseUrl: string;
+    /** The bytes32 stamped into the signed order's `builder` field; never caller-supplied. */
+    readonly polymarketBuilderCode: Hex;
+    readonly polymarketBuilderFeeConfigVersion: string;
+    /** The ruled rates the live builder registry must still match; never used as a fee to charge. */
+    readonly polymarketRuledBuilderFeeBps: Readonly<{
+        maker: number;
+        taker: number;
+    }>;
+    readonly polymarketTimeoutMs: number;
+    readonly hyperliquidApiBaseUrl: string;
+    readonly hyperliquidBuilderFeeConfigVersion: string;
+    /** The ruled pending state of the builder field; never a fee this constructor may charge. */
+    readonly hyperliquidBuilderAttributionStatus: typeof HL_BUILDER_ATTRIBUTION_STATUS;
+    readonly hyperliquidTimeoutMs: number;
+}
+export declare function parseDecimalRate(raw: string, name?: string): DecimalRate;
+export declare function loadExecutionServiceConfig(env?: NodeJS.ProcessEnv): ExecutionServiceConfig | undefined;
+export declare function attributedFeeAmount(amount: bigint, rate: DecimalRate): bigint;