otto-intel-mcp 0.1.0

package/dist/boot-redaction.js

@@ -0,0 +1,54 @@
+/**
+ * boot-redaction.ts — what the hosted boot may print about a configuration failure.
+ *
+ * viem embeds the RPC URL in its error messages (`URL: https://…/v2/<key>`) and strips only basic-auth
+ * credentials from it — not a key carried in the path or the query. A boot-time RPC failure printed
+ * verbatim would therefore write `BASE_RPC_URL` (an API key) to the Railway log. Every configuration or
+ * boot error goes through `redactBootMessage` before stderr: URLs become `<url>`, and any configured
+ * secret VALUE that survives is replaced by its NAME. The chain-id check itself throws a fixed message
+ * (`execution-delegation.ts`); this is the second layer, for every other path that could carry a value.
+ */
+/** The hosted service's secret-bearing variables. Values are never printed; names are. */
+export const REDACTED_ENV_NAMES = Object.freeze([
+    'CDP_API_KEY_ID',
+    'CDP_API_KEY_SECRET',
+    'CDP_WALLET_SECRET',
+    'OTTO_DELEGATION_SERVER_SECRET',
+    'BASE_RPC_URL',
+    'INTERNAL_API_KEY',
+    'DATA_ENDPOINTS_INTERNAL_URL',
+    'LIFI_API_KEY',
+    'LIFI_BASE_URL',
+    'POLYMARKET_CLOB_URL',
+    'HYPERLIQUID_API_URL',
+    // The published STDIO entrypoint's config (c2 fold 08-30): its raw printer was the one
+    // remaining unredacted boot path, and its URL/key fields were absent from this list.
+    'X402_PRIVATE_KEY',
+    'X402_BASE_URL',
+    'X402_RPC_URL',
+]);
+const URL_PATTERN = /https?:\/\/\S+/gi;
+/** A value shorter than this is not treated as a secret (it would blank ordinary words). */
+const MIN_VALUE_LENGTH = 8;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Redact URLs and every configured secret value from a message that is about to be printed. */
+export function redactBootMessage(message, env = process.env, names = REDACTED_ENV_NAMES) {
+    let out = message.replace(URL_PATTERN, '<url>');
+    const values = names
+        .map((name) => ({ name, value: env[name]?.trim() ?? '' }))
+        .filter(({ value }) => value.length >= MIN_VALUE_LENGTH)
+        .sort((a, b) => b.value.length - a.value.length); // longest first: a value that contains another is replaced whole
+    for (const { name, value } of values) {
+        // A function replacer: a `$` inside the replacement text must never be interpreted as a pattern reference.
+        out = out.replace(new RegExp(escapeRegExp(value), 'g'), () => `<${name}>`);
+    }
+    return out;
+}
+/** The one line the boot prints for a failure; never the raw error. */
+export function bootFailureLine(prefix, error, env = process.env) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `${prefix}: ${redactBootMessage(message, env)}\n`;
+}
+//# sourceMappingURL=boot-redaction.js.map

package/dist/data-source.d.ts

@@ -0,0 +1,7 @@
+import type { IntelToolDefinition, ToolArguments } from './tool-definitions.js';
+export interface IntelReadOptions {
+    readonly signal?: AbortSignal;
+}
+export interface IntelDataSource {
+    read(definition: IntelToolDefinition, input: ToolArguments, options?: IntelReadOptions): Promise<unknown>;
+}

package/dist/data-source.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data-source.js.map

package/dist/errors.d.ts

@@ -0,0 +1,70 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export declare class WarmReadUnavailableError extends Error {
+    readonly retryAfterSeconds?: number;
+    constructor(retryAfterSeconds?: number);
+}
+export declare class UpstreamReadError extends Error {
+    constructor();
+}
+export declare class X402PaymentError extends Error {
+    constructor();
+}
+export declare class PaymentLayerUnavailableError extends Error {
+    constructor();
+}
+export declare class PaymentRequiredError extends Error {
+    readonly challenge: Readonly<Record<string, unknown>>;
+    constructor(challenge: Readonly<Record<string, unknown>>);
+}
+export declare class FreeReadUnavailableError extends Error {
+    constructor();
+}
+export type X402ReadRetryReason = 'route_incomplete' | 'paid_response_invalid' | 'rail_unavailable' | 'rail_rejected' | 'settlement_ambiguous';
+/** What the paid rail's answer PROVES about a presented authorization (2026-08-28, ws-13). */
+export type X402SettlementState = 'recoverable' | 'not_settled' | 'not_applicable';
+export declare class X402ReadRetryableError extends Error {
+    readonly paymentPresented: boolean;
+    readonly reason: X402ReadRetryReason;
+    /**
+     * `recoverable` — the rail may have settled (transport failure, 200 without a receipt, 503 after
+     * the authorization reached it): the durable rail replays a settled body for the same
+     * authorization + input, or completes an uncharged attempt. `not_settled` — the rail answered a
+     * non-402 4xx to the request itself, before any settlement: nothing was charged, the
+     * authorization is unspent. `not_applicable` — no authorization was presented.
+     */
+    readonly settlementState: X402SettlementState;
+    readonly upstreamStatus?: number;
+    readonly retryAfterSeconds?: number;
+    constructor(paymentPresented: boolean, reason?: X402ReadRetryReason, details?: {
+        settlementState?: 'recoverable' | 'not_settled';
+        upstreamStatus?: number;
+        retryAfterSeconds?: number;
+    });
+}
+/**
+ * The paid rail's PAYWALL answered 402 to a PRESENTED authorization — proven by its own v2
+ * PAYMENT-REQUIRED document in the answer, which the paywall emits only at the verify stage, before
+ * any settlement. Nothing was settled and nothing was charged. The rail's reason travels verbatim
+ * (`Payment required` = it saw no payment; `invalid_exact_evm_insufficient_balance` = transient):
+ * the same authorization may be re-presented before it expires when the cause is transient, and the
+ * fresh requirement is attached for signing again otherwise. A 402 WITHOUT that document (the SDK's
+ * post-handler settlement failure carries settlement headers and no requirement) is NOT this error —
+ * it may be settled on-chain and stays recoverable.
+ * (2026-08-28, ws-13: the hosted forward used the x402 v1 header name, the v2 paywall answered its
+ * unpaid 402, and this case was being reported as "durably owned — retry" — a false claim that made
+ * every paying MCP client loop.)
+ */
+export declare class PaymentRejectedError extends Error {
+    readonly challenge: Readonly<Record<string, unknown>>;
+    readonly upstreamReason: string | undefined;
+    constructor(challenge: Readonly<Record<string, unknown>>, upstreamReason?: string);
+}
+export declare class RequestCancelledError extends Error {
+    constructor();
+}
+export declare function mapToolError(error: unknown): CallToolResult;
+/**
+ * Defense-in-depth for the hosted transport: backend preparation vocabulary must
+ * never cross its MCP boundary.
+ */
+export declare function mapHostedToolError(error: unknown): CallToolResult;

package/dist/errors.js

@@ -0,0 +1,221 @@
+export class WarmReadUnavailableError extends Error {
+    retryAfterSeconds;
+    constructor(retryAfterSeconds) {
+        super('warm data is unavailable');
+        this.name = 'WarmReadUnavailableError';
+        this.retryAfterSeconds = retryAfterSeconds;
+    }
+}
+export class UpstreamReadError extends Error {
+    constructor() {
+        super('upstream read failed');
+        this.name = 'UpstreamReadError';
+    }
+}
+export class X402PaymentError extends Error {
+    constructor() {
+        super('x402 data payment failed');
+        this.name = 'X402PaymentError';
+    }
+}
+export class PaymentLayerUnavailableError extends Error {
+    constructor() {
+        super('x402 payment verification is unavailable');
+        this.name = 'PaymentLayerUnavailableError';
+    }
+}
+export class PaymentRequiredError extends Error {
+    challenge;
+    constructor(challenge) {
+        super('x402 payment is required');
+        this.name = 'PaymentRequiredError';
+        this.challenge = challenge;
+    }
+}
+export class FreeReadUnavailableError extends Error {
+    constructor() {
+        super('no free result is available for this input');
+        this.name = 'FreeReadUnavailableError';
+    }
+}
+export class X402ReadRetryableError extends Error {
+    paymentPresented;
+    reason;
+    /**
+     * `recoverable` — the rail may have settled (transport failure, 200 without a receipt, 503 after
+     * the authorization reached it): the durable rail replays a settled body for the same
+     * authorization + input, or completes an uncharged attempt. `not_settled` — the rail answered a
+     * non-402 4xx to the request itself, before any settlement: nothing was charged, the
+     * authorization is unspent. `not_applicable` — no authorization was presented.
+     */
+    settlementState;
+    upstreamStatus;
+    retryAfterSeconds;
+    constructor(paymentPresented, reason = 'route_incomplete', details = {}) {
+        super('the x402 route did not complete this read');
+        this.name = 'X402ReadRetryableError';
+        this.paymentPresented = paymentPresented;
+        this.reason = reason;
+        this.settlementState = paymentPresented
+            ? (details.settlementState ?? 'recoverable')
+            : 'not_applicable';
+        this.upstreamStatus = details.upstreamStatus;
+        this.retryAfterSeconds = details.retryAfterSeconds;
+    }
+}
+/**
+ * The paid rail's PAYWALL answered 402 to a PRESENTED authorization — proven by its own v2
+ * PAYMENT-REQUIRED document in the answer, which the paywall emits only at the verify stage, before
+ * any settlement. Nothing was settled and nothing was charged. The rail's reason travels verbatim
+ * (`Payment required` = it saw no payment; `invalid_exact_evm_insufficient_balance` = transient):
+ * the same authorization may be re-presented before it expires when the cause is transient, and the
+ * fresh requirement is attached for signing again otherwise. A 402 WITHOUT that document (the SDK's
+ * post-handler settlement failure carries settlement headers and no requirement) is NOT this error —
+ * it may be settled on-chain and stays recoverable.
+ * (2026-08-28, ws-13: the hosted forward used the x402 v1 header name, the v2 paywall answered its
+ * unpaid 402, and this case was being reported as "durably owned — retry" — a false claim that made
+ * every paying MCP client loop.)
+ */
+export class PaymentRejectedError extends Error {
+    challenge;
+    upstreamReason;
+    constructor(challenge, upstreamReason) {
+        super('the paid rail did not accept the presented authorization');
+        this.name = 'PaymentRejectedError';
+        this.challenge = challenge;
+        this.upstreamReason = upstreamReason;
+    }
+}
+export class RequestCancelledError extends Error {
+    constructor() {
+        super('request cancelled');
+        this.name = 'RequestCancelledError';
+    }
+}
+export function mapToolError(error) {
+    if (error instanceof PaymentRequiredError) {
+        return {
+            isError: true,
+            content: [{ type: 'text', text: JSON.stringify(error.challenge) }],
+        };
+    }
+    if (error instanceof FreeReadUnavailableError) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: 'No free result is available for this input. Your free call was not spent; choose another input or use the paid x402 route.',
+                },
+            ],
+        };
+    }
+    if (error instanceof PaymentRejectedError) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        ...error.challenge,
+                        error: 'payment_rejected',
+                        status: 402,
+                        retryable: true,
+                        reuse_x_payment: true,
+                        payment_presented: true,
+                        settlement_state: 'not_settled',
+                        reason: error.upstreamReason ?? 'authorization_not_accepted',
+                        message: `The paid rail did not accept the presented authorization (${error.upstreamReason ?? 'authorization_not_accepted'}): this attempt was not settled and not charged. If the cause is transient, retry the exact same tool input with the same x_payment before it expires; otherwise sign the accepted requirement in payment_required and retry this tool with the new signed payload.`,
+                    }),
+                },
+            ],
+        };
+    }
+    if (error instanceof X402ReadRetryableError) {
+        const message = !error.paymentPresented
+            ? 'The x402 route was unavailable before a signed authorization was presented. Request a new payment requirement before another attempt.'
+            : error.settlementState === 'not_settled'
+                ? `The paid rail refused this request before any settlement (HTTP ${error.upstreamStatus ?? 'error'}): nothing was charged and the signed authorization is unspent. Retry the exact same tool input with the same x_payment, or sign a fresh requirement if it has expired.`
+                : 'Retry the exact same tool input with the same x_payment: the paid rail replays a settled response without a second charge, or completes the attempt if nothing was charged. Do not sign a new authorization for this input while this one is valid — a second authorization can settle on its own.';
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        error: 'x402_read_retriable',
+                        retryable: true,
+                        reuse_x_payment: error.paymentPresented,
+                        payment_presented: error.paymentPresented,
+                        settlement_state: error.settlementState,
+                        reason: error.reason,
+                        ...(error.upstreamStatus === undefined ? {} : { upstream_status: error.upstreamStatus }),
+                        ...(error.retryAfterSeconds === undefined
+                            ? {}
+                            : { retry_after_seconds: error.retryAfterSeconds }),
+                        message,
+                    }),
+                },
+            ],
+        };
+    }
+    if (error instanceof PaymentLayerUnavailableError) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: 'Payment verification is temporarily unavailable. No intelligence payload was released.',
+                },
+            ],
+        };
+    }
+    if (error instanceof RequestCancelledError) {
+        return {
+            isError: true,
+            content: [{ type: 'text', text: 'The intelligence request was cancelled.' }],
+        };
+    }
+    if (error instanceof WarmReadUnavailableError) {
+        const retry = error.retryAfterSeconds
+            ? ` Retry after about ${error.retryAfterSeconds} seconds.`
+            : ' Retry later.';
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Temporarily unavailable: this scanner's cached data is cold or stale. No paid refresh was triggered.${retry}`,
+                },
+            ],
+        };
+    }
+    if (error instanceof X402PaymentError) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: 'The read-only x402 data call could not complete. Check the payer wallet configuration and balance, then retry.',
+                },
+            ],
+        };
+    }
+    return {
+        isError: true,
+        content: [
+            {
+                type: 'text',
+                text: 'otto intelligence is temporarily unavailable. No order or fund-moving action was attempted.',
+            },
+        ],
+    };
+}
+/**
+ * Defense-in-depth for the hosted transport: backend preparation vocabulary must
+ * never cross its MCP boundary.
+ */
+export function mapHostedToolError(error) {
+    return mapToolError(error instanceof WarmReadUnavailableError ? new FreeReadUnavailableError() : error);
+}
+//# sourceMappingURL=errors.js.map

package/dist/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;