otto-execute 0.1.0

package/dist/vendor/otto-intel-mcp/execution-config.js

@@ -0,0 +1,443 @@
+import { getAddress } from 'viem';
+import { MAX_ARTIFACT_TTL_MS } from './artifact-id.js';
+export const LIFI_INTEGRATOR = 'ottowallet';
+export const DEFAULT_LIFI_FEE_BPS = 10;
+export const DEFAULT_LIFI_AGGREGATE_FEE_CAP_RATE = '0.0025';
+export const DEFAULT_LIFI_FEE_CONFIG_VERSION = 'lifi-2026-08-16-10bps-25bps-cap-v2';
+export const DEFAULT_OTTO_LIFI_FEE_RECIPIENT = getAddress('0x0E84dDEdAaE6A779c462C22a59F301EC31B6b808');
+export const DEFAULT_LIFI_PLATFORM_FEE_RECIPIENT = getAddress('0xC06eBbeFD94032b85424D51906e2a335Efae264b');
+export const LIFI_DIAMOND_ADDRESS = getAddress('0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE');
+/**
+ * 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 const LIFI_FEE_FORWARDER_V1_MAINNET = getAddress('0x685527c551Cc40ce1f1C9818cD8683307076E4eD');
+export const LIFI_FEE_FORWARDER_V1 = getAddress('0xC18D9E84b8687A2645447A61e52c455Dac1675e1');
+export const LIFI_FEE_FORWARDER_V2 = getAddress('0xCE40449B773a3E6E5e769ADb4e567179d4828cbd');
+export const LIFI_FEE_FORWARDERS_BY_CHAIN = Object.freeze({
+    1: Object.freeze([LIFI_FEE_FORWARDER_V1_MAINNET, LIFI_FEE_FORWARDER_V2]),
+    56: Object.freeze([LIFI_FEE_FORWARDER_V1, LIFI_FEE_FORWARDER_V2]),
+    137: Object.freeze([LIFI_FEE_FORWARDER_V1, LIFI_FEE_FORWARDER_V2]),
+    8453: Object.freeze([LIFI_FEE_FORWARDER_V1, LIFI_FEE_FORWARDER_V2]),
+    42161: Object.freeze([LIFI_FEE_FORWARDER_V1, LIFI_FEE_FORWARDER_V2]),
+    43114: Object.freeze([LIFI_FEE_FORWARDER_V1, LIFI_FEE_FORWARDER_V2]),
+});
+/** The reviewed FeeForwarder list for a chain, or undefined when the chain is outside the reviewed set. */
+export function reviewedLiFiFeeForwarders(chainId) {
+    return LIFI_FEE_FORWARDERS_BY_CHAIN[chainId];
+}
+export function isReviewedLiFiFeeForwarder(chainId, address) {
+    const reviewed = LIFI_FEE_FORWARDERS_BY_CHAIN[chainId];
+    if (!reviewed)
+        return false;
+    const candidate = getAddress(address);
+    return reviewed.some((entry) => entry === candidate);
+}
+/**
+ * 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 function unreviewedFeeForwarderMessage(chainId, callTo, approveTo) {
+    const reviewed = LIFI_FEE_FORWARDERS_BY_CHAIN[chainId] ?? [];
+    return (`LI.FI fee-forwarding leg calls ${getAddress(callTo)} (approveTo ${getAddress(approveTo)}), which is not a ` +
+        `reviewed FeeForwarder deployment on chain ${chainId} (reviewed: ${reviewed.join(', ') || 'none'}). ` +
+        `If LI.FI rolled out a new FeeForwarder, review it against lifinance/contracts deployments/<chain>.json ` +
+        `and on-chain bytecode, then add it to LIFI_FEE_FORWARDERS_BY_CHAIN — never accept by shape.`);
+}
+/**
+ * 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 const LIFI_CCTP_USDC_BY_CHAIN = Object.freeze({
+    1: getAddress('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
+    137: getAddress('0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359'),
+    8453: getAddress('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'),
+    42161: getAddress('0xaf88d065e77c8cC2239327C5EDb3A432268e5831'),
+    43114: getAddress('0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E'),
+});
+/** LI.FI bridge tool key pinned in the quote request so the reviewed facet is the only one quoted. */
+export 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 function isEnumeratedCctpBridgeRoute(fromChainId, toChainId, fromToken, toToken) {
+    if (fromChainId === toChainId)
+        return false;
+    const source = LIFI_CCTP_USDC_BY_CHAIN[fromChainId];
+    const destination = LIFI_CCTP_USDC_BY_CHAIN[toChainId];
+    if (!source || !destination)
+        return false;
+    return getAddress(fromToken) === source && getAddress(toToken) === destination;
+}
+// =============================================================================
+// Polymarket CLOB V2 order construction (spec §7.3)
+// =============================================================================
+/** The only chain Polymarket's CTF exchanges are deployed on; also the EIP-712 domain chain id. */
+export const POLYMARKET_CHAIN_ID = 137;
+/** Collateral and conditional-token atomic precision; mirrors the SDK's COLLATERAL_TOKEN_DECIMALS. */
+export 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 const OTTO_PM_BUILDER_CODE = '0x910082696e647acd3f9486c1a6366840c780a26db5b6aa781892ebf69c48508c';
+export const PM_BYTES32_ZERO = `0x${'00'.repeat(32)}`;
+/**
+ * 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 const PM_RULED_BUILDER_FEE_BPS = Object.freeze({
+    maker: 0,
+    taker: 0,
+});
+export const DEFAULT_PM_BUILDER_FEE_CONFIG_VERSION = 'pm-2026-08-17-builder-0bps-0bps-v1';
+export const POLYMARKET_TICK_SIZES = ['0.1', '0.01', '0.001', '0.0001'];
+/**
+ * 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 const POLYMARKET_ROUNDING_BY_TICK_SIZE = Object.freeze({
+    '0.1': Object.freeze({ price: 1, size: 2, amount: 3 }),
+    '0.01': Object.freeze({ price: 2, size: 2, amount: 4 }),
+    '0.001': Object.freeze({ price: 3, size: 2, amount: 5 }),
+    '0.0001': Object.freeze({ price: 4, size: 2, amount: 6 }),
+});
+export function isPolymarketTickSize(value) {
+    return POLYMARKET_TICK_SIZES.includes(value);
+}
+export const POLYMARKET_EIP712_DOMAIN_NAME = 'Polymarket CTF Exchange';
+export const POLYMARKET_EIP712_DOMAIN_VERSION = '2';
+export 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 const POLYMARKET_ORDER_V2_EIP712_FIELDS = Object.freeze([
+    Object.freeze({ name: 'salt', type: 'uint256' }),
+    Object.freeze({ name: 'maker', type: 'address' }),
+    Object.freeze({ name: 'signer', type: 'address' }),
+    Object.freeze({ name: 'tokenId', type: 'uint256' }),
+    Object.freeze({ name: 'makerAmount', type: 'uint256' }),
+    Object.freeze({ name: 'takerAmount', type: 'uint256' }),
+    Object.freeze({ name: 'side', type: 'uint8' }),
+    Object.freeze({ name: 'signatureType', type: 'uint8' }),
+    Object.freeze({ name: 'timestamp', type: 'uint256' }),
+    Object.freeze({ name: 'metadata', type: 'bytes32' }),
+    Object.freeze({ name: 'builder', type: 'bytes32' }),
+]);
+// =============================================================================
+// Hyperliquid perp L1 action construction (spec §7.2)
+// =============================================================================
+/**
+ * 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 const HYPERLIQUID_L1_SIGNATURE_CHAIN_ID = 1337;
+export const HYPERLIQUID_EIP712_DOMAIN_NAME = 'Exchange';
+export const HYPERLIQUID_EIP712_DOMAIN_VERSION = '1';
+export const HYPERLIQUID_AGENT_PRIMARY_TYPE = 'Agent';
+/** The L1-action domain has no verifying contract; the venue pins the zero address. */
+export const HYPERLIQUID_EIP712_VERIFYING_CONTRACT = '0x0000000000000000000000000000000000000000';
+/** `"a"` on mainnet, `"b"` on testnet (signing/mod.js:186). v1 constructs mainnet actions only. */
+export 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 const HYPERLIQUID_AGENT_EIP712_FIELDS = Object.freeze([
+    Object.freeze({ name: 'source', type: 'string' }),
+    Object.freeze({ name: 'connectionId', type: 'bytes32' }),
+]);
+/**
+ * `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 const HYPERLIQUID_ACTION_KEY_ORDER = Object.freeze([
+    'type',
+    'orders',
+    'grouping',
+]);
+/** `c` (client order id) is appended only when the order carries one. */
+export const HYPERLIQUID_ORDER_KEY_ORDER = Object.freeze([
+    'a',
+    'b',
+    'p',
+    's',
+    'r',
+    't',
+]);
+export const HYPERLIQUID_TRIGGER_KEY_ORDER = Object.freeze([
+    'isMarket',
+    'triggerPx',
+    'tpsl',
+]);
+/** Perp price precision ceiling: at most `MAX_DECIMALS - szDecimals` fractional digits. */
+export const HYPERLIQUID_PERP_MAX_DECIMALS = 6;
+/** …and at most 5 significant digits, unless the price is an integer (always accepted). */
+export 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 const HYPERLIQUID_TIME_IN_FORCE = ['Gtc', 'Ioc', 'Alo'];
+/** `na` for a lone entry; `normalTpsl` binds fixed-size TP/SL legs to the entry (client.ts:1876). */
+export const HYPERLIQUID_ORDER_GROUPINGS = ['na', 'normalTpsl'];
+/**
+ * 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 const HL_BUILDER_ATTRIBUTION_STATUS = 'pending_step0_builder_fee_approval';
+export const DEFAULT_HL_BUILDER_FEE_CONFIG_VERSION = 'hl-2026-08-17-builder-unwired-v1';
+/** Env names that would carry a builder VALUE. Fenced: see `HL_BUILDER_ATTRIBUTION_STATUS`. */
+const HL_BUILDER_VALUE_ENV_NAMES = [
+    'OTTO_HL_BUILDER_ADDRESS',
+    'OTTO_HL_BUILDER_FEE_TENTHS_BPS',
+];
+function parseEnabled(raw) {
+    if (raw === undefined || raw.trim() === '')
+        return false;
+    if (raw === 'true')
+        return true;
+    if (raw === 'false')
+        return false;
+    throw new Error('OTTO_EXECUTION_MCP_ENABLED must be true or false');
+}
+function positiveInteger(raw, fallback, name) {
+    if (raw === undefined || raw.trim() === '')
+        return fallback;
+    const parsed = Number(raw);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw new Error(`${name} must be a positive integer`);
+    }
+    return parsed;
+}
+export function parseDecimalRate(raw, name = 'OTTO_LIFI_FEE') {
+    const value = raw.trim();
+    const match = /^(0|1)\.(\d{1,6})$/.exec(value);
+    if (!match)
+        throw new Error(`${name} must be a decimal rate with 1-6 fractional digits`);
+    const numerator = BigInt(match[1]) * 10n ** BigInt(match[2].length) + BigInt(match[2]);
+    const denominator = 10n ** BigInt(match[2].length);
+    if (numerator <= 0n || numerator >= denominator) {
+        throw new Error(`${name} must be greater than 0 and less than 1`);
+    }
+    return Object.freeze({ decimal: value, numerator, denominator });
+}
+function checkedBaseUrl(raw) {
+    const url = new URL(raw);
+    if (url.username || url.password)
+        throw new Error('LIFI_BASE_URL must not contain credentials');
+    const isOfficial = url.protocol === 'https:' && url.origin === 'https://li.quest';
+    const isLoopback = ['http:', 'https:'].includes(url.protocol) &&
+        ['localhost', '127.0.0.1', '::1', '[::1]'].includes(url.hostname);
+    if (!isOfficial && !isLoopback) {
+        throw new Error('LIFI_BASE_URL must use https://li.quest or a loopback test server');
+    }
+    return url.toString().replace(/\/$/, '');
+}
+function checkedConfigVersion(raw) {
+    const value = raw?.trim() || DEFAULT_LIFI_FEE_CONFIG_VERSION;
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(value)) {
+        throw new Error('OTTO_LIFI_FEE_CONFIG_VERSION is invalid');
+    }
+    return value;
+}
+function checkedClobBaseUrl(raw) {
+    const url = new URL(raw);
+    if (url.username || url.password) {
+        throw new Error('POLYMARKET_CLOB_URL must not contain credentials');
+    }
+    const isOfficial = url.protocol === 'https:' && url.origin === 'https://clob.polymarket.com';
+    const isLoopback = ['http:', 'https:'].includes(url.protocol) &&
+        ['localhost', '127.0.0.1', '::1', '[::1]'].includes(url.hostname);
+    if (!isOfficial && !isLoopback) {
+        throw new Error('POLYMARKET_CLOB_URL must use https://clob.polymarket.com or a loopback test server');
+    }
+    return url.toString().replace(/\/$/, '');
+}
+function checkedBuilderCode(raw) {
+    const value = (raw?.trim() || OTTO_PM_BUILDER_CODE).toLowerCase();
+    if (!/^0x[0-9a-f]{64}$/.test(value)) {
+        throw new Error('OTTO_PM_BUILDER_CODE must be a 32-byte hex string');
+    }
+    if (value === PM_BYTES32_ZERO) {
+        // A zero builder code is exactly what the CLOB reads as "no builder": the order would be
+        // constructed, signed, and filled with Otto's attribution absent rather than refused.
+        throw new Error('OTTO_PM_BUILDER_CODE must not be the zero builder code');
+    }
+    return value;
+}
+function checkedHyperliquidBaseUrl(raw) {
+    const url = new URL(raw);
+    if (url.username || url.password) {
+        throw new Error('HYPERLIQUID_API_URL must not contain credentials');
+    }
+    const isOfficial = url.protocol === 'https:' && url.origin === 'https://api.hyperliquid.xyz';
+    const isLoopback = ['http:', 'https:'].includes(url.protocol) &&
+        ['localhost', '127.0.0.1', '::1', '[::1]'].includes(url.hostname);
+    if (!isOfficial && !isLoopback) {
+        throw new Error('HYPERLIQUID_API_URL must use https://api.hyperliquid.xyz or a loopback test server');
+    }
+    return url.toString().replace(/\/$/, '');
+}
+function checkedFeeBps(raw, fallback, name) {
+    if (raw === undefined || raw.trim() === '')
+        return fallback;
+    const parsed = Number(raw);
+    if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > 10_000) {
+        throw new Error(`${name} must be an integer between 0 and 10000`);
+    }
+    return parsed;
+}
+function basisPointsRate(basisPoints) {
+    if (!Number.isSafeInteger(basisPoints) || basisPoints <= 0 || basisPoints >= 10_000) {
+        throw new Error('default LI.FI fee must be between 1 and 9,999 basis points');
+    }
+    const decimalDigits = basisPoints.toString().padStart(4, '0').replace(/0+$/, '');
+    return parseDecimalRate(`0.${decimalDigits}`, 'default LI.FI fee');
+}
+export function loadExecutionServiceConfig(env = process.env) {
+    if (!parseEnabled(env.OTTO_EXECUTION_MCP_ENABLED))
+        return undefined;
+    const feeOverride = env.OTTO_LIFI_FEE?.trim();
+    const recipientOverride = env.OTTO_LIFI_FEE_RECIPIENT?.trim();
+    if ((feeOverride || recipientOverride) && !env.OTTO_LIFI_FEE_CONFIG_VERSION?.trim()) {
+        throw new Error('OTTO_LIFI_FEE_CONFIG_VERSION is required when overriding the LI.FI fee or recipient');
+    }
+    let feeRecipient;
+    try {
+        feeRecipient = getAddress(recipientOverride || DEFAULT_OTTO_LIFI_FEE_RECIPIENT);
+    }
+    catch {
+        throw new Error('OTTO_LIFI_FEE_RECIPIENT must be a valid EVM address');
+    }
+    if (feeRecipient === getAddress('0x0000000000000000000000000000000000000000')) {
+        throw new Error('OTTO_LIFI_FEE_RECIPIENT must not be the zero address');
+    }
+    if (feeRecipient === DEFAULT_LIFI_PLATFORM_FEE_RECIPIENT) {
+        throw new Error('OTTO_LIFI_FEE_RECIPIENT must differ from the LI.FI platform recipient');
+    }
+    const lifiFee = feeOverride
+        ? parseDecimalRate(feeOverride)
+        : basisPointsRate(DEFAULT_LIFI_FEE_BPS);
+    const lifiAggregateFeeCap = parseDecimalRate(DEFAULT_LIFI_AGGREGATE_FEE_CAP_RATE, 'LI.FI aggregate fee cap');
+    if (lifiFee.numerator * lifiAggregateFeeCap.denominator >=
+        lifiAggregateFeeCap.numerator * lifiFee.denominator) {
+        throw new Error('OTTO_LIFI_FEE must be below the LI.FI aggregate fee cap');
+    }
+    const artifactTtlMs = positiveInteger(env.OTTO_EXECUTION_ARTIFACT_TTL_MS, 300_000, 'OTTO_EXECUTION_ARTIFACT_TTL_MS');
+    if (artifactTtlMs > MAX_ARTIFACT_TTL_MS) {
+        throw new Error(`OTTO_EXECUTION_ARTIFACT_TTL_MS must not exceed ${MAX_ARTIFACT_TTL_MS} ms, the artifact freshness ceiling`);
+    }
+    // Same discipline as the LI.FI fee: a value override without a version bump would silently change
+    // what `fee_attribution.config_version` means, so it is a config-time throw.
+    const builderCodeOverride = env.OTTO_PM_BUILDER_CODE?.trim();
+    const makerBpsOverride = env.OTTO_PM_BUILDER_MAKER_FEE_BPS?.trim();
+    const takerBpsOverride = env.OTTO_PM_BUILDER_TAKER_FEE_BPS?.trim();
+    if ((builderCodeOverride || makerBpsOverride || takerBpsOverride) &&
+        !env.OTTO_PM_BUILDER_FEE_CONFIG_VERSION?.trim()) {
+        throw new Error('OTTO_PM_BUILDER_FEE_CONFIG_VERSION is required when overriding the Polymarket builder code or ruled rates');
+    }
+    const polymarketBuilderFeeConfigVersion = env.OTTO_PM_BUILDER_FEE_CONFIG_VERSION?.trim() || DEFAULT_PM_BUILDER_FEE_CONFIG_VERSION;
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(polymarketBuilderFeeConfigVersion)) {
+        throw new Error('OTTO_PM_BUILDER_FEE_CONFIG_VERSION is invalid');
+    }
+    // The Hyperliquid builder value is a Founder ruling that has not landed (spec §7.2). Reading it
+    // from the environment would let an unruled address or fee rate enter a digest the user signs, so
+    // the presence of either variable is a config-time throw rather than a value this code adopts.
+    for (const name of HL_BUILDER_VALUE_ENV_NAMES) {
+        if (env[name]?.trim()) {
+            throw new Error(`${name} must not be set: the Hyperliquid builder fee is spec'd and valueless until the Step-0 approveBuilderFee reversal lands`);
+        }
+    }
+    const hyperliquidBuilderFeeConfigVersion = env.OTTO_HL_BUILDER_FEE_CONFIG_VERSION?.trim() || DEFAULT_HL_BUILDER_FEE_CONFIG_VERSION;
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(hyperliquidBuilderFeeConfigVersion)) {
+        throw new Error('OTTO_HL_BUILDER_FEE_CONFIG_VERSION is invalid');
+    }
+    return Object.freeze({
+        artifactTtlMs,
+        lifiApiKey: env.LIFI_API_KEY?.trim() || undefined,
+        lifiBaseUrl: checkedBaseUrl(env.LIFI_BASE_URL?.trim() || 'https://li.quest/v1'),
+        lifiAggregateFeeCap,
+        lifiAllowedFeeRecipients: Object.freeze([DEFAULT_LIFI_PLATFORM_FEE_RECIPIENT, feeRecipient]),
+        lifiFee,
+        lifiFeeConfigVersion: checkedConfigVersion(env.OTTO_LIFI_FEE_CONFIG_VERSION),
+        lifiFeeRecipient: feeRecipient,
+        lifiTimeoutMs: positiveInteger(env.LIFI_TIMEOUT_MS, 30_000, 'LIFI_TIMEOUT_MS'),
+        polymarketClobBaseUrl: checkedClobBaseUrl(env.POLYMARKET_CLOB_URL?.trim() || 'https://clob.polymarket.com'),
+        polymarketBuilderCode: checkedBuilderCode(builderCodeOverride),
+        polymarketBuilderFeeConfigVersion,
+        polymarketRuledBuilderFeeBps: Object.freeze({
+            maker: checkedFeeBps(makerBpsOverride, PM_RULED_BUILDER_FEE_BPS.maker, 'OTTO_PM_BUILDER_MAKER_FEE_BPS'),
+            taker: checkedFeeBps(takerBpsOverride, PM_RULED_BUILDER_FEE_BPS.taker, 'OTTO_PM_BUILDER_TAKER_FEE_BPS'),
+        }),
+        polymarketTimeoutMs: positiveInteger(env.POLYMARKET_TIMEOUT_MS, 30_000, 'POLYMARKET_TIMEOUT_MS'),
+        hyperliquidApiBaseUrl: checkedHyperliquidBaseUrl(env.HYPERLIQUID_API_URL?.trim() || 'https://api.hyperliquid.xyz'),
+        hyperliquidBuilderFeeConfigVersion,
+        hyperliquidBuilderAttributionStatus: HL_BUILDER_ATTRIBUTION_STATUS,
+        hyperliquidTimeoutMs: positiveInteger(env.HYPERLIQUID_TIMEOUT_MS, 30_000, 'HYPERLIQUID_TIMEOUT_MS'),
+    });
+}
+export function attributedFeeAmount(amount, rate) {
+    return (amount * rate.numerator) / rate.denominator;
+}
+//# sourceMappingURL=execution-config.js.map

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

@@ -0,0 +1,165 @@
+/**
+ * execution-delegated-definition.ts — the ONE execution tool that submits: `otto_submit_under_delegation`.
+ * Kept apart from the prepare-only `EXECUTION_TOOL_DEFINITIONS` on purpose: it registers only when the
+ * hosted service holds Otto's CDP developer credentials, it is not read-only, and its caller is
+ * authenticated per request by a header the arguments never carry.
+ */
+import { z } from 'zod';
+export declare const DELEGATED_EXECUTION_TOOL_NAME: "otto_submit_under_delegation";
+/** Per-request caller authentication rides THIS header — never a tool argument (arguments are logged). */
+export declare const DELEGATION_AUTH_HEADER: "x-otto-delegation-auth";
+export declare const SUBMIT_UNDER_DELEGATION_INPUT_SCHEMA: z.ZodObject<{
+    userId: z.ZodString;
+    envelope: z.ZodObject<{
+        schema_version: z.ZodLiteral<"1">;
+        artifact_id: z.ZodString;
+        rail: z.ZodLiteral<"lifi">;
+        operation: z.ZodLiteral<"swap">;
+        intent_digest: z.ZodString;
+        account_binding: z.ZodObject<{
+            kind: z.ZodEnum<{
+                safe: "safe";
+                eoa: "eoa";
+            }>;
+            address: z.ZodString;
+            chainId: z.ZodNumber;
+            protocol_roles: z.ZodObject<{
+                lifi: z.ZodObject<{
+                    sender: z.ZodString;
+                    receiver: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        required_capabilities: z.ZodArray<z.ZodEnum<{
+            send_evm_transaction: "send_evm_transaction";
+            submit_evm_batch: "submit_evm_batch";
+        }>>;
+        payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"evm_execution_plan">;
+            chain_id: z.ZodNumber;
+            steps: z.ZodArray<z.ZodObject<{
+                to: z.ZodString;
+                value: z.ZodString;
+                data: z.ZodString;
+                kind: z.ZodEnum<{
+                    call: "call";
+                    approve_reset: "approve_reset";
+                    approve: "approve";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">;
+        fee_attribution: z.ZodObject<{
+            mechanism: z.ZodLiteral<"lifi_integrator_fee">;
+            config_version: z.ZodString;
+        }, z.core.$strict>;
+        replay_disclosure: z.ZodObject<{
+            artifact_role: z.ZodLiteral<"construction_aid">;
+            freshness_boundary: z.ZodLiteral<"valid_until">;
+            onchain_replay_boundary: z.ZodLiteral<"signer_account_nonce">;
+            tool_guarantees_single_execution: z.ZodLiteral<false>;
+        }, z.core.$strict>;
+        assertions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            result: z.ZodLiteral<"passed">;
+        }, z.core.$strict>>;
+        valid_until: z.ZodString;
+        submission: z.ZodObject<{
+            method: z.ZodEnum<{
+                send_evm_transaction: "send_evm_transaction";
+                submit_evm_batch: "submit_evm_batch";
+            }>;
+            chain_id: z.ZodNumber;
+            artifact_id: z.ZodString;
+            payload_digest: z.ZodString;
+            artifact_digest: z.ZodString;
+            adapter_owned_fields: z.ZodTuple<[z.ZodLiteral<"nonce">, z.ZodLiteral<"gas">, z.ZodLiteral<"serialization">], null>;
+            client_ref: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    prepareInput: z.ZodObject<{
+        accountProfile: z.ZodObject<{
+            kind: z.ZodEnum<{
+                safe: "safe";
+                eoa: "eoa";
+            }>;
+            address: z.ZodString;
+            chainId: z.ZodNumber;
+        }, z.core.$strict>;
+        chainId: z.ZodNumber;
+        fromToken: z.ZodString;
+        toToken: z.ZodString;
+        fromAmount: z.ZodString;
+        slippage: z.ZodObject<{
+            maxBps: z.ZodNumber;
+            minAmountOut: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        client_ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SubmitUnderDelegationInput = z.infer<typeof SUBMIT_UNDER_DELEGATION_INPUT_SCHEMA>;
+/**
+ * What the tool REGISTERS as its input schema: permissive on purpose. The MCP SDK validates the registered
+ * schema BEFORE the handler runs, which would answer an unauthenticated caller with the exact validation
+ * failure — a schema oracle in front of the caller check. Registering a passthrough object moves ALL
+ * validation behind the header check: the handler parses `SUBMIT_UNDER_DELEGATION_INPUT_SCHEMA` itself,
+ * strictly, after the caller is accepted. The strict schema stays exported for consumers.
+ */
+export declare const DELEGATED_TOOL_TRANSPORT_SCHEMA: z.ZodObject<{}, z.core.$loose>;
+export declare const DELEGATED_SEND_RESULT_SCHEMA: z.ZodObject<{
+    status: z.ZodLiteral<"sent">;
+    user_id: z.ZodString;
+    address: z.ZodString;
+    chain_id: z.ZodLiteral<8453>;
+    artifact_id: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        kind: z.ZodEnum<{
+            call: "call";
+            approve_reset: "approve_reset";
+            approve: "approve";
+        }>;
+        to: z.ZodString;
+        transaction_hash: z.ZodString;
+        status: z.ZodLiteral<"success">;
+        block_number: z.ZodString;
+        gas_used: z.ZodString;
+    }, z.core.$strict>>;
+    fence: z.ZodObject<{
+        policy_id: z.ZodString;
+        policy_name: z.ZodString;
+        rules_digest: z.ZodString;
+        per_swap_cap_usd: z.ZodLiteral<5000>;
+    }, z.core.$strict>;
+    delegation: z.ZodObject<{
+        expires_at: z.ZodString;
+    }, z.core.$strict>;
+    replayed: z.ZodOptional<z.ZodBoolean>;
+    verification: z.ZodObject<{
+        checks: z.ZodArray<z.ZodString>;
+        gross: z.ZodString;
+        min_amount_out: z.ZodString;
+        otto_fee_atomic: z.ZodString;
+        otto_fee_recipient: z.ZodString;
+        fee_config_version: z.ZodString;
+        receiver: z.ZodString;
+        call_data_digest: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type DelegatedSendResult = z.infer<typeof DELEGATED_SEND_RESULT_SCHEMA>;
+/** Not read-only, not idempotent: every accepted call moves the end user's funds through the delegation. */
+export declare const DELEGATED_TOOL_ANNOTATIONS: Readonly<{
+    readOnlyHint: false;
+    destructiveHint: true;
+    idempotentHint: false;
+    openWorldHint: true;
+}>;
+export interface DelegatedExecutionToolDefinition {
+    readonly name: typeof DELEGATED_EXECUTION_TOOL_NAME;
+    readonly title: string;
+    readonly description: string;
+    /** The registered (transport) schema — permissive; the strict one is parsed after authentication. */
+    readonly inputSchema: typeof DELEGATED_TOOL_TRANSPORT_SCHEMA;
+    readonly strictInputSchema: typeof SUBMIT_UNDER_DELEGATION_INPUT_SCHEMA;
+    readonly outputSchema: typeof DELEGATED_SEND_RESULT_SCHEMA;
+}
+export declare const DELEGATED_EXECUTION_TOOL_DEFINITION: DelegatedExecutionToolDefinition;