otto-execute 0.1.0

package/dist/vendor/otto-intel-mcp/execution-tool-definitions.js

@@ -0,0 +1,1051 @@
+import { hashTypedData } from 'viem';
+import { z } from 'zod';
+import { isArtifactFreshnessWellFormed } from './artifact-id.js';
+import { HL_BUILDER_ATTRIBUTION_STATUS, HYPERLIQUID_ACTION_KEY_ORDER, HYPERLIQUID_AGENT_EIP712_FIELDS, HYPERLIQUID_AGENT_PRIMARY_TYPE, HYPERLIQUID_EIP712_DOMAIN_NAME, HYPERLIQUID_EIP712_DOMAIN_VERSION, HYPERLIQUID_EIP712_VERIFYING_CONTRACT, HYPERLIQUID_L1_SIGNATURE_CHAIN_ID, HYPERLIQUID_MAINNET_AGENT_SOURCE, HYPERLIQUID_ORDER_GROUPINGS, HYPERLIQUID_ORDER_KEY_ORDER, HYPERLIQUID_TIME_IN_FORCE, HYPERLIQUID_TRIGGER_KEY_ORDER, isEnumeratedCctpBridgeRoute, LIFI_CCTP_USDC_BY_CHAIN, POLYMARKET_CHAIN_ID, POLYMARKET_EIP712_DOMAIN_NAME, POLYMARKET_EIP712_DOMAIN_VERSION, POLYMARKET_ORDER_PRIMARY_TYPE, POLYMARKET_ORDER_V2_EIP712_FIELDS, POLYMARKET_TICK_SIZES, } from './execution-config.js';
+const EVM_ADDRESS_PATTERN = /^0x[0-9a-fA-F]{40}$/;
+const ERC20_APPROVE_SELECTOR = '0x095ea7b3';
+const HEX_DATA_PATTERN = /^0x(?:[0-9a-fA-F]{2})*$/;
+const DIGEST_PATTERN = /^0x[0-9a-fA-F]{64}$/;
+const UINT256_MAX = (1n << 256n) - 1n;
+const addressSchema = z
+    .string()
+    .regex(EVM_ADDRESS_PATTERN, 'must be a 20-byte EVM address')
+    .refine((value) => !/^0x0{40}$/i.test(value), 'must not be the zero address');
+const positiveUintString = z
+    .string()
+    .regex(/^[1-9]\d*$/, 'must be a positive decimal integer')
+    .refine((value) => BigInt(value) <= UINT256_MAX, 'must fit uint256');
+export const ACCOUNT_PROFILE_SCHEMA = z
+    .object({
+    kind: z.enum(['eoa', 'safe']),
+    address: addressSchema,
+    chainId: z.number().int().positive().safe(),
+})
+    .strict();
+export const PREPARE_SWAP_INPUT_SCHEMA = z
+    .object({
+    accountProfile: ACCOUNT_PROFILE_SCHEMA,
+    chainId: z.number().int().positive().safe(),
+    fromToken: addressSchema.describe('ERC20 input token address; native-token routes are out of v1.'),
+    toToken: addressSchema.describe('ERC20 output token address; native-token routes are out of v1.'),
+    fromAmount: positiveUintString.describe('Exact input amount in atomic token units.'),
+    slippage: z
+        .object({
+        maxBps: z.number().int().min(1).max(1_000),
+        minAmountOut: positiveUintString.optional(),
+    })
+        .strict(),
+    client_ref: z.string().trim().min(1).max(128).optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.fromToken.toLowerCase() === value.toToken.toLowerCase()) {
+        context.addIssue({
+            code: 'custom',
+            path: ['toToken'],
+            message: 'must differ from fromToken',
+        });
+    }
+});
+export const PREPARE_BRIDGE_INPUT_SCHEMA = z
+    .object({
+    accountProfile: ACCOUNT_PROFILE_SCHEMA,
+    fromChainId: z.number().int().positive().safe(),
+    toChainId: z.number().int().positive().safe(),
+    fromToken: addressSchema.describe('Native USDC on the source chain; the v1 bridge route set is USDC-only.'),
+    toToken: addressSchema.describe('Native USDC on the destination chain; the v1 bridge route set is USDC-only.'),
+    fromAmount: positiveUintString.describe('Exact gross input amount in atomic token units.'),
+    destinationRecipient: addressSchema
+        .optional()
+        .describe('Where the destination mint lands. Optional for an EOA, whose address is identical on every EVM chain; REQUIRED for a Safe, whose address is not guaranteed to be the same contract on the destination chain.'),
+    slippage: z
+        .object({
+        maxBps: z.number().int().min(1).max(1_000),
+        minAmountOut: positiveUintString.optional(),
+    })
+        .strict(),
+    client_ref: z.string().trim().min(1).max(128).optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.fromChainId === value.toChainId) {
+        context.addIssue({
+            code: 'custom',
+            path: ['toChainId'],
+            message: 'must differ from fromChainId; same-chain routes belong to otto_prepare_swap',
+        });
+    }
+    if (value.accountProfile.kind === 'safe' && value.destinationRecipient === undefined) {
+        context.addIssue({
+            code: 'custom',
+            path: ['destinationRecipient'],
+            message: 'required for a Safe profile: a Safe address is not guaranteed to be the same account on the destination chain',
+        });
+    }
+});
+const accountBindingSchema = ACCOUNT_PROFILE_SCHEMA.extend({
+    protocol_roles: z
+        .object({
+        lifi: z
+            .object({
+            sender: addressSchema,
+            receiver: addressSchema,
+        })
+            .strict(),
+    })
+        .strict(),
+}).strict();
+const evmStepSchema = z
+    .object({
+    to: addressSchema,
+    value: z.string().regex(/^\d+$/),
+    data: z.string().regex(HEX_DATA_PATTERN),
+    kind: z.enum(['approve_reset', 'approve', 'call']),
+})
+    .strict();
+/**
+ * Decode a canonical `approve(address,uint256)` call. Returns undefined for any other calldata,
+ * so the envelope schema can bind approval shape without trusting the step's declared kind.
+ */
+export function decodeApprovalCalldata(data) {
+    if (data.length !== 138 || data.slice(0, 10).toLowerCase() !== ERC20_APPROVE_SELECTOR) {
+        return undefined;
+    }
+    const spenderWord = data.slice(10, 74);
+    if (!/^0{24}[0-9a-fA-F]{40}$/.test(spenderWord))
+        return undefined;
+    return {
+        spender: `0x${spenderWord.slice(24)}`.toLowerCase(),
+        amount: BigInt(`0x${data.slice(74)}`),
+    };
+}
+export const EXECUTION_ENVELOPE_SCHEMA = z
+    .object({
+    schema_version: z.literal('1'),
+    artifact_id: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/),
+    rail: z.literal('lifi'),
+    operation: z.literal('swap'),
+    intent_digest: z.string().regex(DIGEST_PATTERN),
+    account_binding: accountBindingSchema,
+    required_capabilities: z.array(z.enum(['send_evm_transaction', 'submit_evm_batch'])).length(1),
+    payload: z.discriminatedUnion('kind', [
+        z
+            .object({
+            kind: z.literal('evm_execution_plan'),
+            chain_id: z.number().int().positive().safe(),
+            steps: z.array(evmStepSchema).length(3),
+        })
+            .strict(),
+    ]),
+    fee_attribution: z
+        .object({
+        mechanism: z.literal('lifi_integrator_fee'),
+        config_version: z.string().min(1).max(64),
+    })
+        .strict(),
+    replay_disclosure: z
+        .object({
+        artifact_role: z.literal('construction_aid'),
+        freshness_boundary: z.literal('valid_until'),
+        onchain_replay_boundary: z.literal('signer_account_nonce'),
+        tool_guarantees_single_execution: z.literal(false),
+    })
+        .strict(),
+    assertions: z
+        .array(z
+        .object({
+        id: z.string().min(1).max(64),
+        result: z.literal('passed'),
+    })
+        .strict())
+        .min(1),
+    valid_until: z.string().datetime({ offset: true }),
+    submission: z
+        .object({
+        method: z.enum(['send_evm_transaction', 'submit_evm_batch']),
+        chain_id: z.number().int().positive().safe(),
+        artifact_id: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/),
+        payload_digest: z.string().regex(DIGEST_PATTERN),
+        artifact_digest: z.string().regex(DIGEST_PATTERN),
+        adapter_owned_fields: z.tuple([
+            z.literal('nonce'),
+            z.literal('gas'),
+            z.literal('serialization'),
+        ]),
+        client_ref: z.string().min(1).max(128).optional(),
+    })
+        .strict(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const issue = (path, message) => {
+        context.addIssue({ code: 'custom', path, message });
+    };
+    const account = value.account_binding;
+    const accountAddress = account.address.toLowerCase();
+    if (account.protocol_roles.lifi.sender.toLowerCase() !== accountAddress ||
+        account.protocol_roles.lifi.receiver.toLowerCase() !== accountAddress) {
+        issue(['account_binding', 'protocol_roles', 'lifi'], 'sender and receiver must equal the bound account');
+    }
+    if (account.chainId !== value.payload.chain_id ||
+        account.chainId !== value.submission.chain_id) {
+        issue(['payload', 'chain_id'], 'all envelope chain identifiers must match');
+    }
+    if (value.submission.artifact_id !== value.artifact_id) {
+        issue(['submission', 'artifact_id'], 'must match the envelope artifact_id');
+    }
+    const expectedCapability = account.kind === 'eoa' ? 'send_evm_transaction' : 'submit_evm_batch';
+    if (value.required_capabilities[0] !== expectedCapability ||
+        value.submission.method !== expectedCapability) {
+        issue(['required_capabilities'], 'capability and submission method must match the account kind');
+    }
+    const [reset, approve, call] = value.payload.steps;
+    if (reset?.kind !== 'approve_reset' || approve?.kind !== 'approve' || call?.kind !== 'call') {
+        issue(['payload', 'steps'], 'execution steps must be ordered allowance reset, approve, then call');
+    }
+    if (value.payload.steps.some((step) => step.value !== '0')) {
+        issue(['payload', 'steps'], 'ERC20 execution steps must carry zero native value');
+    }
+    // The reset step is what makes the plan executable from any prior allowance state, including
+    // approval-race-guarded tokens that revert on a non-zero to non-zero approve. Bind its shape
+    // here so a dropped, re-pointed, or non-zero reset cannot pass envelope validation.
+    if (reset && approve) {
+        const decodedReset = decodeApprovalCalldata(reset.data);
+        const decodedApprove = decodeApprovalCalldata(approve.data);
+        if (!decodedReset || !decodedApprove) {
+            issue(['payload', 'steps'], 'both approval steps must be canonical ERC20 approve calls');
+        }
+        else if (reset.to.toLowerCase() !== approve.to.toLowerCase() ||
+            decodedReset.spender !== decodedApprove.spender) {
+            issue(['payload', 'steps'], 'the allowance reset must target the same token and spender as the approval');
+        }
+        else if (decodedReset.amount !== 0n || decodedApprove.amount <= 0n) {
+            issue(['payload', 'steps'], 'the allowance reset must approve zero and the approval must approve a positive amount');
+        }
+    }
+    // Freshness is constructor-owned: valid_until is re-derivable from the construction
+    // timestamp inside artifact_id and is capped by the ceiling, so a widened expiry is
+    // rejected without any external state.
+    if (!isArtifactFreshnessWellFormed(value.artifact_id, value.valid_until)) {
+        issue(['valid_until'], 'valid_until must follow the artifact_id construction time and stay within the freshness ceiling');
+    }
+});
+const bridgeAccountBindingSchema = ACCOUNT_PROFILE_SCHEMA.extend({
+    protocol_roles: z
+        .object({
+        lifi: z
+            .object({
+            sender: addressSchema,
+            receiver: addressSchema,
+            source_chain_id: z.number().int().positive().safe(),
+            destination_chain_id: z.number().int().positive().safe(),
+            sending_asset: addressSchema,
+            receiving_asset: addressSchema,
+        })
+            .strict(),
+    })
+        .strict(),
+}).strict();
+export const BRIDGE_EXECUTION_ENVELOPE_SCHEMA = z
+    .object({
+    schema_version: z.literal('1'),
+    artifact_id: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/),
+    rail: z.literal('lifi'),
+    operation: z.literal('bridge'),
+    intent_digest: z.string().regex(DIGEST_PATTERN),
+    account_binding: bridgeAccountBindingSchema,
+    required_capabilities: z.array(z.enum(['send_evm_transaction', 'submit_evm_batch'])).length(1),
+    payload: z.discriminatedUnion('kind', [
+        z
+            .object({
+            kind: z.literal('evm_execution_plan'),
+            chain_id: z.number().int().positive().safe(),
+            steps: z.array(evmStepSchema).length(3),
+        })
+            .strict(),
+    ]),
+    fee_attribution: z
+        .object({
+        mechanism: z.literal('lifi_integrator_fee'),
+        config_version: z.string().min(1).max(64),
+    })
+        .strict(),
+    replay_disclosure: z
+        .object({
+        artifact_role: z.literal('construction_aid'),
+        freshness_boundary: z.literal('valid_until'),
+        onchain_replay_boundary: z.literal('signer_account_nonce'),
+        tool_guarantees_single_execution: z.literal(false),
+    })
+        .strict(),
+    assertions: z
+        .array(z
+        .object({
+        id: z.string().min(1).max(64),
+        result: z.literal('passed'),
+    })
+        .strict())
+        .min(1),
+    valid_until: z.string().datetime({ offset: true }),
+    submission: z
+        .object({
+        method: z.enum(['send_evm_transaction', 'submit_evm_batch']),
+        chain_id: z.number().int().positive().safe(),
+        artifact_id: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/),
+        payload_digest: z.string().regex(DIGEST_PATTERN),
+        artifact_digest: z.string().regex(DIGEST_PATTERN),
+        adapter_owned_fields: z.tuple([
+            z.literal('nonce'),
+            z.literal('gas'),
+            z.literal('serialization'),
+        ]),
+        client_ref: z.string().min(1).max(128).optional(),
+    })
+        .strict(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const issue = (path, message) => {
+        context.addIssue({ code: 'custom', path, message });
+    };
+    const account = value.account_binding;
+    const roles = account.protocol_roles.lifi;
+    if (roles.sender.toLowerCase() !== account.address.toLowerCase()) {
+        issue(['account_binding', 'protocol_roles', 'lifi', 'sender'], 'sender must equal the bound account');
+    }
+    // The source chain is the only chain the payload executes on; the destination chain is a
+    // declared fact of the route, never a chain any step is submitted to.
+    if (account.chainId !== roles.source_chain_id ||
+        account.chainId !== value.payload.chain_id ||
+        account.chainId !== value.submission.chain_id) {
+        issue(['payload', 'chain_id'], 'all source-chain identifiers must match the bound account');
+    }
+    // The enumerated v1 route set is carried in the envelope itself, so an adapter re-validates the
+    // route without trusting the constructor that built it. This also subsumes the
+    // destination-differs-from-source check: `isEnumeratedCctpBridgeRoute` returns false for an
+    // equal chain pair, so a separate clause for it would be unreachable by construction.
+    if (!isEnumeratedCctpBridgeRoute(roles.source_chain_id, roles.destination_chain_id, roles.sending_asset, roles.receiving_asset)) {
+        issue(['account_binding', 'protocol_roles', 'lifi'], 'route must be inside the enumerated v1 PolymerCCTP USDC route set');
+    }
+    if (value.submission.artifact_id !== value.artifact_id) {
+        issue(['submission', 'artifact_id'], 'must match the envelope artifact_id');
+    }
+    const expectedCapability = account.kind === 'eoa' ? 'send_evm_transaction' : 'submit_evm_batch';
+    if (value.required_capabilities[0] !== expectedCapability ||
+        value.submission.method !== expectedCapability) {
+        issue(['required_capabilities'], 'capability and submission method must match the account kind');
+    }
+    const [reset, approve, call] = value.payload.steps;
+    if (reset?.kind !== 'approve_reset' || approve?.kind !== 'approve' || call?.kind !== 'call') {
+        issue(['payload', 'steps'], 'execution steps must be ordered allowance reset, approve, then call');
+    }
+    if (value.payload.steps.some((step) => step.value !== '0')) {
+        issue(['payload', 'steps'], 'ERC20 execution steps must carry zero native value');
+    }
+    // Both approval steps must target the source-chain USDC being bridged: an approval pointed at
+    // any other token is an allowance the plan never needed.
+    if (reset &&
+        approve &&
+        (reset.to.toLowerCase() !== roles.sending_asset.toLowerCase() ||
+            approve.to.toLowerCase() !== roles.sending_asset.toLowerCase())) {
+        issue(['payload', 'steps'], 'approval steps must target the bridged source asset');
+    }
+    if (reset && approve) {
+        const decodedReset = decodeApprovalCalldata(reset.data);
+        const decodedApprove = decodeApprovalCalldata(approve.data);
+        if (!decodedReset || !decodedApprove) {
+            issue(['payload', 'steps'], 'both approval steps must be canonical ERC20 approve calls');
+        }
+        else if (reset.to.toLowerCase() !== approve.to.toLowerCase() ||
+            decodedReset.spender !== decodedApprove.spender) {
+            issue(['payload', 'steps'], 'the allowance reset must target the same token and spender as the approval');
+        }
+        else if (decodedReset.amount !== 0n || decodedApprove.amount <= 0n) {
+            issue(['payload', 'steps'], 'the allowance reset must approve zero and the approval must approve a positive amount');
+        }
+    }
+    if (!isArtifactFreshnessWellFormed(value.artifact_id, value.valid_until)) {
+        issue(['valid_until'], 'valid_until must follow the artifact_id construction time and stay within the freshness ceiling');
+    }
+});
+// =============================================================================
+// Polymarket CLOB V2 limit order (spec §7.3)
+// =============================================================================
+const uint256String = z.string().regex(/^\d+$/, 'must be a decimal uint256');
+const bytes32Schema = z.string().regex(/^0x[0-9a-fA-F]{64}$/, 'must be a 32-byte hex value');
+const salt = z.string().regex(/^[1-9]\d*$/, 'must be a positive decimal integer');
+/** Probability price as an exact decimal string; 1-4 fractional digits covers every tick size. */
+const polymarketPriceSchema = z
+    .string()
+    .regex(/^0\.\d{1,4}$/, 'must be a decimal probability strictly between 0 and 1');
+/**
+ * Order size in shares. At most two fractional digits — the precision every tick size rounds size
+ * to — so the constructor never depends on the SDK silently truncating a third digit, and the
+ * derived collateral amount stays exact integer arithmetic.
+ */
+const polymarketSizeSchema = z
+    .string()
+    .regex(/^(?:0|[1-9]\d{0,9})(?:\.\d{1,2})?$/, 'must be a decimal share size with at most 2 fractional digits')
+    .refine((value) => Number(value) > 0, 'must be greater than zero');
+export const PREPARE_POLYMARKET_ORDER_INPUT_SCHEMA = z
+    .object({
+    accountProfile: ACCOUNT_PROFILE_SCHEMA,
+    tokenId: z
+        .string()
+        .regex(/^[1-9]\d{0,77}$/, 'must be a positive decimal CTF token id')
+        .describe('Outcome-token id (NOT the condition id): YES and NO are different token ids.'),
+    side: z.enum(['BUY', 'SELL']),
+    price: polymarketPriceSchema.describe("Limit price as a probability, e.g. '0.045'. Must be an exact multiple of the market's minimum tick size."),
+    size: polymarketSizeSchema.describe('Order size in outcome-token shares.'),
+    client_ref: z.string().trim().min(1).max(128).optional(),
+})
+    .strict();
+const polymarketAccountBindingSchema = ACCOUNT_PROFILE_SCHEMA.extend({
+    protocol_roles: z
+        .object({
+        polymarket: z
+            .object({
+            maker: addressSchema,
+            signer: addressSchema,
+            funder: addressSchema,
+            exchange: addressSchema,
+            token_id: uint256String,
+            signature_type: z.literal(0),
+        })
+            .strict(),
+    })
+        .strict(),
+}).strict();
+/** The SDK's own order args, pre-signing. No `signature` field exists on this shape by design. */
+const POLYMARKET_ORDER_ARGS_SCHEMA = z
+    .object({
+    salt,
+    maker: addressSchema,
+    signer: addressSchema,
+    tokenId: uint256String,
+    makerAmount: uint256String,
+    takerAmount: uint256String,
+    side: z.enum(['BUY', 'SELL']),
+    signatureType: z.literal(0),
+    metadata: bytes32Schema,
+    builder: bytes32Schema,
+    timestamp: uint256String,
+    /** Unsigned POST-time field: the V2 exchange's Order struct does not cover expiration. */
+    expiration: uint256String,
+})
+    .strict();
+const POLYMARKET_TYPED_DATA_SCHEMA = z
+    .object({
+    primary_type: z.literal(POLYMARKET_ORDER_PRIMARY_TYPE),
+    domain: z
+        .object({
+        name: z.literal(POLYMARKET_EIP712_DOMAIN_NAME),
+        version: z.literal(POLYMARKET_EIP712_DOMAIN_VERSION),
+        chainId: z.literal(POLYMARKET_CHAIN_ID),
+        verifyingContract: addressSchema,
+    })
+        .strict(),
+    types: z
+        .object({
+        Order: z
+            .array(z.object({ name: z.string().min(1), type: z.string().min(1) }).strict())
+            .length(POLYMARKET_ORDER_V2_EIP712_FIELDS.length),
+    })
+        .strict(),
+    message: z
+        .object({
+        salt,
+        maker: addressSchema,
+        signer: addressSchema,
+        tokenId: uint256String,
+        makerAmount: uint256String,
+        takerAmount: uint256String,
+        side: z.union([z.literal(0), z.literal(1)]),
+        signatureType: z.literal(0),
+        timestamp: uint256String,
+        metadata: bytes32Schema,
+        builder: bytes32Schema,
+    })
+        .strict(),
+})
+    .strict();
+export const POLYMARKET_ORDER_PAYLOAD_SCHEMA = z
+    .object({
+    kind: z.literal('polymarket_order_v2'),
+    chain_id: z.literal(POLYMARKET_CHAIN_ID),
+    exchange: addressSchema,
+    neg_risk: z.boolean(),
+    tick_size: z.enum(POLYMARKET_TICK_SIZES),
+    /** v1 is a signed limit order; market orders walk a live book and are out of scope. */
+    order_type: z.literal('GTC'),
+    order: POLYMARKET_ORDER_ARGS_SCHEMA,
+    eip712: POLYMARKET_TYPED_DATA_SCHEMA,
+    order_hash: z.string().regex(DIGEST_PATTERN),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const issue = (path, message) => {
+        context.addIssue({ code: 'custom', path, message });
+    };
+    // The pinned struct is what gives every other field its meaning, so an adapter re-checks it
+    // rather than trusting whatever type array arrived with the artifact.
+    const fields = value.eip712.types.Order;
+    if (fields.some((field, index) => field.name !== POLYMARKET_ORDER_V2_EIP712_FIELDS[index]?.name ||
+        field.type !== POLYMARKET_ORDER_V2_EIP712_FIELDS[index]?.type)) {
+        issue(['eip712', 'types', 'Order'], 'must be the pinned CTF Exchange V2 Order struct');
+    }
+    if (value.eip712.domain.verifyingContract.toLowerCase() !== value.exchange.toLowerCase()) {
+        issue(['eip712', 'domain', 'verifyingContract'], 'must equal the payload exchange');
+    }
+    // Two representations of one order: the args the adapter POSTs and the struct it signs. They are
+    // cross-bound here so a tampered POST body cannot diverge from the signed digest.
+    const message = value.eip712.message;
+    const order = value.order;
+    const mismatched = message.salt !== order.salt ||
+        message.maker.toLowerCase() !== order.maker.toLowerCase() ||
+        message.signer.toLowerCase() !== order.signer.toLowerCase() ||
+        message.tokenId !== order.tokenId ||
+        message.makerAmount !== order.makerAmount ||
+        message.takerAmount !== order.takerAmount ||
+        message.timestamp !== order.timestamp ||
+        message.signatureType !== order.signatureType ||
+        message.metadata.toLowerCase() !== order.metadata.toLowerCase() ||
+        message.builder.toLowerCase() !== order.builder.toLowerCase() ||
+        message.side !== (order.side === 'BUY' ? 0 : 1);
+    if (mismatched) {
+        issue(['eip712', 'message'], 'signed order struct must match the order args exactly');
+    }
+    if (order.tokenId !== value.eip712.message.tokenId) {
+        issue(['order', 'tokenId'], 'must match the signed token id');
+    }
+    // The digest is recomputed from the declared domain, struct, and message: the exact bytes the
+    // user's signer will sign. A tampered field that skipped a digest recomputation is refused here.
+    let recomputed;
+    try {
+        recomputed = hashTypedData({
+            domain: {
+                ...value.eip712.domain,
+                verifyingContract: value.eip712.domain.verifyingContract,
+            },
+            types: { Order: [...value.eip712.types.Order] },
+            primaryType: value.eip712.primary_type,
+            message: value.eip712.message,
+        });
+    }
+    catch {
+        recomputed = undefined;
+    }
+    if (recomputed?.toLowerCase() !== value.order_hash.toLowerCase()) {
+        issue(['order_hash'], 'must equal the EIP-712 digest of the declared domain, types, and message');
+    }
+    if (BigInt(order.makerAmount) <= 0n || BigInt(order.takerAmount) <= 0n) {
+        issue(['order'], 'both order legs must carry a positive amount');
+    }
+    // `expiration` is NOT covered by the V2 signed struct, so a non-zero value on a GTC order is an
+    // unsigned promise the exchange may honour or ignore while the signature stays valid. A GTC
+    // artifact therefore declares zero, and an adapter re-checks it here rather than posting it.
+    if (value.order_type === 'GTC' && order.expiration !== '0') {
+        issue(['order', 'expiration'], 'a GTC order must carry a zero expiration');
+    }
+});
+export const POLYMARKET_EXECUTION_ENVELOPE_SCHEMA = z
+    .object({
+    schema_version: z.literal('1'),
+    artifact_id: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/),
+    rail: z.literal('polymarket'),
+    operation: z.literal('pm_order'),
+    intent_digest: z.string().regex(DIGEST_PATTERN),
+    account_binding: polymarketAccountBindingSchema,
+    required_capabilities: z.tuple([z.literal('sign_eip712')]),
+    payload: POLYMARKET_ORDER_PAYLOAD_SCHEMA,
+    fee_attribution: z
+        .object({
+        mechanism: z.literal('polymarket_builder_code'),
+        config_version: z.string().min(1).max(64),
+    })
+        .strict(),
+    replay_disclosure: z
+        .object({
+        artifact_role: z.literal('construction_aid'),
+        freshness_boundary: z.literal('valid_until'),
+        /**
+         * The PM rail's replay boundary is NOT a signer account nonce: an unsigned order struct
+         * carries its own salt and timestamp, so re-signing the same artifact reproduces the same
+         * order hash and the exchange's own order bookkeeping is what rejects the duplicate. Same
+         * Founder ruling as slice 1 (the constructor owns freshness only), correct boundary named.
+         */
+        onchain_replay_boundary: z.literal('exchange_order_hash'),
+        tool_guarantees_single_execution: z.literal(false),
+    })
+        .strict(),
+    assertions: z
+        .array(z.object({ id: z.string().min(1).max(64), result: z.literal('passed') }).strict())
+        .min(1),
+    valid_until: z.string().datetime({ offset: true }),
+    submission: z
+        .object({
+        method: z.literal('sign_eip712'),
+        chain_id: z.literal(POLYMARKET_CHAIN_ID),
+        artifact_id: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/),
+        payload_digest: z.string().regex(DIGEST_PATTERN),
+        artifact_digest: z.string().regex(DIGEST_PATTERN),
+        /** The adapter owns the signature and the authenticated CLOB post; nothing else. */
+        adapter_owned_fields: z.tuple([z.literal('signature'), z.literal('clob_post')]),
+        client_ref: z.string().min(1).max(128).optional(),
+    })
+        .strict(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const issue = (path, message) => {
+        context.addIssue({ code: 'custom', path, message });
+    };
+    const account = value.account_binding;
+    const roles = account.protocol_roles.polymarket;
+    const accountAddress = account.address.toLowerCase();
+    // v1 binds one EOA to all three roles: it signs, it makes, and it funds. A Safe profile would
+    // need a signature type this spec has not ruled on, so it never reaches this schema.
+    if (account.kind !== 'eoa' ||
+        roles.maker.toLowerCase() !== accountAddress ||
+        roles.signer.toLowerCase() !== accountAddress ||
+        roles.funder.toLowerCase() !== accountAddress) {
+        issue(['account_binding', 'protocol_roles', 'polymarket'], 'maker, signer, and funder must all equal the bound EOA');
+    }
+    if (account.chainId !== POLYMARKET_CHAIN_ID ||
+        value.payload.chain_id !== POLYMARKET_CHAIN_ID ||
+        value.submission.chain_id !== POLYMARKET_CHAIN_ID) {
+        issue(['payload', 'chain_id'], 'Polymarket artifacts are Polygon-only');
+    }
+    if (roles.exchange.toLowerCase() !== value.payload.exchange.toLowerCase() ||
+        roles.token_id !== value.payload.order.tokenId ||
+        roles.signature_type !== value.payload.order.signatureType) {
+        issue(['account_binding', 'protocol_roles', 'polymarket'], 'bound exchange, token id, and signature type must match the signed order');
+    }
+    // Roles live INSIDE the signed struct (spec §4), so binding them outside is only meaningful if
+    // the signed struct carries the same addresses.
+    if (value.payload.order.maker.toLowerCase() !== roles.maker.toLowerCase() ||
+        value.payload.order.signer.toLowerCase() !== roles.signer.toLowerCase()) {
+        issue(['payload', 'order'], 'signed maker and signer must match the bound account roles');
+    }
+    if (value.submission.artifact_id !== value.artifact_id) {
+        issue(['submission', 'artifact_id'], 'must match the envelope artifact_id');
+    }
+    if (!isArtifactFreshnessWellFormed(value.artifact_id, value.valid_until)) {
+        issue(['valid_until'], 'valid_until must follow the artifact_id construction time and stay within the freshness ceiling');
+    }
+});
+// =============================================================================
+// Hyperliquid perp L1 action (spec §7.2)
+// =============================================================================
+/**
+ * Exact, normalized decimal: no leading zeros, no trailing zeros after the point, strictly positive.
+ * The caller's string is what lands in the signed action verbatim, so the grid checks in
+ * `hyperliquid-order-assertions.ts` validate it rather than rounding it onto the venue's grid.
+ */
+const hyperliquidDecimalSchema = z
+    .string()
+    .regex(/^(?:0|[1-9]\d{0,15})(?:\.\d{0,14}[1-9])?$/, 'must be a normalized positive decimal: no leading zeros, no trailing zeros after the point')
+    .refine((value) => value !== '0', 'must be greater than zero');
+const hyperliquidClientOrderIdSchema = z
+    .string()
+    .regex(/^0x[0-9a-f]{32}$/, 'must be 0x followed by 32 lowercase hex characters');
+const hyperliquidLimitTypeSchema = z
+    .object({
+    limit: z.object({ tif: z.enum(HYPERLIQUID_TIME_IN_FORCE) }).strict(),
+})
+    .strict();
+const hyperliquidTriggerTypeSchema = z
+    .object({
+    trigger: z
+        .object({
+        /** Market triggers only: a limit trigger can arm and never fill, leaving the bracket unenforced. */
+        isMarket: z.literal(true),
+        triggerPx: hyperliquidDecimalSchema,
+        tpsl: z.enum(['tp', 'sl']),
+    })
+        .strict(),
+})
+    .strict();
+/**
+ * One order leg, with keys declared in the venue's canonical msgpack order. The declaration order is
+ * load-bearing: zod rebuilds parsed objects in schema order, so this is what fixes the key order of
+ * the emitted artifact, and the envelope's own refinement checks it against
+ * `HYPERLIQUID_ORDER_KEY_ORDER` so a schema edit that drifts from the pinned order fails loudly.
+ */
+const HYPERLIQUID_ORDER_LEG_SCHEMA = z
+    .object({
+    a: z.number().int().min(0).safe(),
+    b: z.boolean(),
+    p: hyperliquidDecimalSchema,
+    s: hyperliquidDecimalSchema,
+    r: z.boolean(),
+    t: z.union([hyperliquidLimitTypeSchema, hyperliquidTriggerTypeSchema]),
+    c: hyperliquidClientOrderIdSchema,
+})
+    .strict();
+/**
+ * The canonical `order` action. `.strict()` is the schema-level bind on the RULED valueless builder
+ * field (spec §7.2): a `builder` key cannot pass envelope validation at all, so an unruled attribution
+ * value cannot reach an artifact through this schema even if a future constructor tried to stamp one.
+ */
+const HYPERLIQUID_ORDER_ACTION_SCHEMA = z
+    .object({
+    type: z.literal('order'),
+    orders: z.array(HYPERLIQUID_ORDER_LEG_SCHEMA).min(1).max(3),
+    grouping: z.enum(HYPERLIQUID_ORDER_GROUPINGS),
+})
+    .strict();
+const HYPERLIQUID_SIGNING_DECLARATION_SCHEMA = z
+    .object({
+    scheme: z.literal('hyperliquid_l1_agent_eip712'),
+    primary_type: z.literal(HYPERLIQUID_AGENT_PRIMARY_TYPE),
+    domain: z
+        .object({
+        name: z.literal(HYPERLIQUID_EIP712_DOMAIN_NAME),
+        version: z.literal(HYPERLIQUID_EIP712_DOMAIN_VERSION),
+        /** Hyperliquid pins 1337 for every L1 action, whatever chain the wallet is connected to. */
+        chainId: z.literal(HYPERLIQUID_L1_SIGNATURE_CHAIN_ID),
+        /** The L1-action domain has no verifying contract, so `addressSchema`'s zero-check cannot apply. */
+        verifyingContract: z.literal(HYPERLIQUID_EIP712_VERIFYING_CONTRACT),
+    })
+        .strict(),
+    types: z
+        .object({
+        Agent: z
+            .array(z.object({ name: z.string().min(1), type: z.string().min(1) }).strict())
+            .length(HYPERLIQUID_AGENT_EIP712_FIELDS.length),
+    })
+        .strict(),
+    /** `"a"` is mainnet; a testnet artifact would carry `"b"` and is out of v1 scope. */
+    source: z.literal(HYPERLIQUID_MAINNET_AGENT_SOURCE),
+    connection_id: z
+        .object({
+        hash: z.literal('keccak256'),
+        preimage: z.tuple([
+            z.literal('msgpack(action)'),
+            z.literal('nonce_uint64_be'),
+            z.literal('vault_address_marker'),
+            z.literal('vault_address_bytes'),
+            z.literal('expires_after_marker'),
+            z.literal('expires_after_uint64_be'),
+        ]),
+        /** The nonce is chosen at signing time; the constructor never pre-commits one (§10). */
+        nonce_owner: z.literal('adapter'),
+    })
+        .strict(),
+})
+    .strict();
+export const HYPERLIQUID_L1_ACTION_PAYLOAD_SCHEMA = z
+    .object({
+    kind: z.literal('hyperliquid_l1_action'),
+    chain_id: z.literal(HYPERLIQUID_L1_SIGNATURE_CHAIN_ID),
+    action: HYPERLIQUID_ORDER_ACTION_SCHEMA,
+    signing: HYPERLIQUID_SIGNING_DECLARATION_SCHEMA,
+    /** Declared profile fact only. `null` means the action trades the signer's own account. */
+    vault_address: addressSchema.nullable(),
+    /**
+     * Constructor-owned expiry, inside the signed digest. This is what makes the artifact's own
+     * freshness bound VENUE-ENFORCED on this rail: Hyperliquid rejects an action received after
+     * `expiresAfter` ("a timestamp in milliseconds after which the action will be rejected").
+     */
+    expires_after: z.number().int().positive().safe(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const issue = (path, message) => {
+        context.addIssue({ code: 'custom', path, message });
+    };
+    // msgpack encodes keys in insertion order, so the emitted key order is part of what the signature
+    // commits to. Checked here against the pinned constants so a schema-declaration edit that drifts
+    // from them cannot ship silently.
+    const actionKeys = Object.keys(value.action);
+    if (actionKeys.length !== HYPERLIQUID_ACTION_KEY_ORDER.length ||
+        actionKeys.some((key, index) => key !== HYPERLIQUID_ACTION_KEY_ORDER[index])) {
+        issue(['action'], 'action keys must be in the canonical Hyperliquid msgpack order');
+    }
+    const expectedLegKeys = [...HYPERLIQUID_ORDER_KEY_ORDER, 'c'];
+    for (const [index, leg] of value.action.orders.entries()) {
+        const legKeys = Object.keys(leg);
+        if (legKeys.length !== expectedLegKeys.length ||
+            legKeys.some((key, position) => key !== expectedLegKeys[position])) {
+            issue(['action', 'orders', index], 'order leg keys must be in the canonical msgpack order');
+        }
+        if ('trigger' in leg.t) {
+            const triggerKeys = Object.keys(leg.t.trigger);
+            if (triggerKeys.length !== HYPERLIQUID_TRIGGER_KEY_ORDER.length ||
+                triggerKeys.some((key, position) => key !== HYPERLIQUID_TRIGGER_KEY_ORDER[position])) {
+                issue(['action', 'orders', index, 't', 'trigger'], 'trigger keys must be in the canonical msgpack order');
+            }
+        }
+    }
+    const fields = value.signing.types.Agent;
+    if (fields.some((field, index) => field.name !== HYPERLIQUID_AGENT_EIP712_FIELDS[index]?.name ||
+        field.type !== HYPERLIQUID_AGENT_EIP712_FIELDS[index]?.type)) {
+        issue(['signing', 'types', 'Agent'], 'must be the pinned Hyperliquid Agent struct');
+    }
+    if (value.signing.domain.chainId !== value.chain_id) {
+        issue(['signing', 'domain', 'chainId'], 'must equal the payload signature chain id');
+    }
+    // All legs are one order on one market: a bundle whose legs name different assets is not a
+    // bracket, and the grouping the venue applies would bind unrelated markets together.
+    const assetIds = new Set(value.action.orders.map((leg) => leg.a));
+    if (assetIds.size !== 1) {
+        issue(['action', 'orders'], 'every leg must name the same perp asset id');
+    }
+    const clientOrderIds = new Set(value.action.orders.map((leg) => leg.c));
+    if (clientOrderIds.size !== value.action.orders.length) {
+        issue(['action', 'orders'], 'each leg must carry a distinct client order id');
+    }
+    // `normalTpsl` is what binds fixed-size reduce-only triggers to the entry; a lone entry declaring
+    // it, or a bracket declaring `na`, describes a different venue behaviour than the legs present.
+    const triggerLegs = value.action.orders.filter((leg) => 'trigger' in leg.t);
+    const expectedGrouping = triggerLegs.length > 0 ? 'normalTpsl' : 'na';
+    if (value.action.grouping !== expectedGrouping) {
+        issue(['action', 'grouping'], `must be ${expectedGrouping} for ${triggerLegs.length} trigger legs`);
+    }
+    // Every trigger leg is a reduce-only close of the entry, on the opposite side, at its own trigger
+    // price. A trigger that is not reduce-only OPENS a position instead of closing one.
+    const entryLegs = value.action.orders.filter((leg) => 'limit' in leg.t);
+    if (entryLegs.length !== 1) {
+        issue(['action', 'orders'], 'exactly one limit entry leg is required');
+    }
+    const entry = entryLegs[0];
+    for (const [index, leg] of value.action.orders.entries()) {
+        if (!('trigger' in leg.t) || !entry)
+            continue;
+        if (leg.r !== true) {
+            issue(['action', 'orders', index, 'r'], 'a trigger leg must be reduce-only');
+        }
+        if (leg.b === entry.b) {
+            issue(['action', 'orders', index, 'b'], 'a trigger leg must close the entry, so it sits on the opposite side');
+        }
+        if (leg.s !== entry.s) {
+            issue(['action', 'orders', index, 's'], 'a fixed-size trigger leg must match the entry size');
+        }
+        if (leg.p !== leg.t.trigger.triggerPx) {
+            issue(['action', 'orders', index, 'p'], 'a market trigger leg prices at its own trigger price');
+        }
+    }
+    const takeProfitLegs = value.action.orders.filter((leg) => 'trigger' in leg.t && leg.t.trigger.tpsl === 'tp');
+    const stopLossLegs = value.action.orders.filter((leg) => 'trigger' in leg.t && leg.t.trigger.tpsl === 'sl');
+    if (takeProfitLegs.length > 1 || stopLossLegs.length > 1) {
+        issue(['action', 'orders'], 'at most one take-profit and one stop-loss leg are supported');
+    }
+});
+const hyperliquidAccountBindingSchema = ACCOUNT_PROFILE_SCHEMA.extend({
+    protocol_roles: z
+        .object({
+        hyperliquid: z
+            .object({
+            /** The Hyperliquid account of record whose margin and positions the action moves. */
+            master: addressSchema,
+            /**
+             * Who signs the L1 action. Equal to `master` when the user signs every order themselves, or
+             * a user-held approved API wallet. Otto NEVER derives one (spec §11).
+             */
+            trading_signer: addressSchema,
+            /** Declared profile fact; `null` for the signer's own account. */
+            vault_address: addressSchema.nullable(),
+            asset: z.string().min(1).max(32),
+            /** Positional index in the live perp universe. */
+            asset_id: z.number().int().min(0).safe(),
+            sz_decimals: z.number().int().min(0).max(18),
+        })
+            .strict(),
+    })
+        .strict(),
+}).strict();
+export const PREPARE_PERP_ORDER_INPUT_SCHEMA = z
+    .object({
+    accountProfile: ACCOUNT_PROFILE_SCHEMA.describe('The Hyperliquid master account. `chainId` must be 1337, the signature chain id Hyperliquid pins for every L1 action.'),
+    asset: z
+        .string()
+        .regex(/^[A-Za-z0-9]{1,32}$/, 'must be a perp symbol from the live Hyperliquid universe')
+        .describe("Perp symbol exactly as the venue names it, e.g. 'BTC', 'kPEPE'. Case-sensitive."),
+    side: z.enum(['BUY', 'SELL']),
+    size: hyperliquidDecimalSchema.describe("Order size in base units, e.g. '0.01'. At most szDecimals fractional digits for this perp."),
+    limitPrice: hyperliquidDecimalSchema.describe('Limit price. Must sit on the venue grid: at most 5 significant digits unless integer, and at most (6 - szDecimals) decimals.'),
+    timeInForce: z
+        .enum(HYPERLIQUID_TIME_IN_FORCE)
+        .default('Gtc')
+        .describe("Gtc rests, Ioc fills-or-cancels, Alo posts only. There is no market order: name your own aggressive limit price with 'Ioc' instead."),
+    reduceOnly: z.boolean().default(false),
+    takeProfitPrice: hyperliquidDecimalSchema
+        .optional()
+        .describe('Optional reduce-only market take-profit trigger, bundled with grouping normalTpsl.'),
+    stopLossPrice: hyperliquidDecimalSchema
+        .optional()
+        .describe('Optional reduce-only market stop-loss trigger, bundled with grouping normalTpsl.'),
+    tradingSigner: addressSchema
+        .optional()
+        .describe('The address that will sign, when it is not the master account itself: a user-held approved API wallet. Declared, never derived.'),
+    vaultAddress: addressSchema
+        .optional()
+        .describe('Trade on behalf of this vault or sub-account. A declared profile fact only.'),
+    client_ref: z.string().trim().min(1).max(128).optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.takeProfitPrice !== undefined &&
+        value.takeProfitPrice === value.stopLossPrice) {
+        context.addIssue({
+            code: 'custom',
+            path: ['stopLossPrice'],
+            message: 'must differ from takeProfitPrice',
+        });
+    }
+    if (value.accountProfile.chainId !== HYPERLIQUID_L1_SIGNATURE_CHAIN_ID) {
+        context.addIssue({
+            code: 'custom',
+            path: ['accountProfile', 'chainId'],
+            message: `must be ${HYPERLIQUID_L1_SIGNATURE_CHAIN_ID}, the signature chain id Hyperliquid pins for L1 actions`,
+        });
+    }
+});
+export const HYPERLIQUID_EXECUTION_ENVELOPE_SCHEMA = z
+    .object({
+    schema_version: z.literal('1'),
+    artifact_id: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/),
+    rail: z.literal('hyperliquid'),
+    operation: z.literal('perp_order'),
+    intent_digest: z.string().regex(DIGEST_PATTERN),
+    account_binding: hyperliquidAccountBindingSchema,
+    required_capabilities: z.tuple([z.literal('sign_hyperliquid_l1')]),
+    payload: HYPERLIQUID_L1_ACTION_PAYLOAD_SCHEMA,
+    fee_attribution: z
+        .object({
+        mechanism: z.literal('hyperliquid_builder_fee'),
+        config_version: z.string().min(1).max(64),
+        /**
+         * The RULED state of the builder value (Founder 2026-08-17, spec §7.2): spec'd and VALUELESS
+         * until the Step-0 `approveBuilderFee` reversal lands. Carried as a machine-readable marker so
+         * a consumer can tell "attribution pending a ruling" apart from "attribution missing", and so
+         * the follow-up fold that wires `{b, f}` is a visible state change rather than a silent one.
+         */
+        status: z.literal(HL_BUILDER_ATTRIBUTION_STATUS),
+    })
+        .strict(),
+    replay_disclosure: z
+        .object({
+        artifact_role: z.literal('construction_aid'),
+        freshness_boundary: z.literal('valid_until'),
+        /**
+         * The venue-correct boundary for this rail, and it is NOT a signer account nonce: the signed
+         * digest covers an adapter-chosen Hyperliquid nonce AND the constructor's `expiresAfter`.
+         * Hyperliquid stores "the 100 highest nonces per address" and requires every new action to
+         * carry a nonce larger than the smallest of them and never previously used, within
+         * `(T - 2 days, T + 1 day)`; it also rejects any action received after `expiresAfter`. So
+         * re-signing this artifact needs a fresh nonce and still expires with the artifact — but the
+         * constructor cannot enforce single execution, which is why it says so (§10).
+         */
+        onchain_replay_boundary: z.literal('signer_nonce_and_expires_after'),
+        tool_guarantees_single_execution: z.literal(false),
+    })
+        .strict(),
+    assertions: z
+        .array(z.object({ id: z.string().min(1).max(64), result: z.literal('passed') }).strict())
+        .min(1),
+    valid_until: z.string().datetime({ offset: true }),
+    submission: z
+        .object({
+        method: z.literal('sign_hyperliquid_l1'),
+        chain_id: z.literal(HYPERLIQUID_L1_SIGNATURE_CHAIN_ID),
+        artifact_id: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/),
+        payload_digest: z.string().regex(DIGEST_PATTERN),
+        artifact_digest: z.string().regex(DIGEST_PATTERN),
+        /** The adapter owns the nonce, the signature, and the authenticated exchange POST; nothing else. */
+        adapter_owned_fields: z.tuple([
+            z.literal('nonce'),
+            z.literal('signature'),
+            z.literal('exchange_post'),
+        ]),
+        client_ref: z.string().min(1).max(128).optional(),
+    })
+        .strict(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const issue = (path, message) => {
+        context.addIssue({ code: 'custom', path, message });
+    };
+    const account = value.account_binding;
+    const roles = account.protocol_roles.hyperliquid;
+    // Hyperliquid recovers an L1 action's signer with ecrecover, so the signing account must be an
+    // EOA. A Safe would need ERC-1271, which the venue does not accept.
+    if (account.kind !== 'eoa' || roles.master.toLowerCase() !== account.address.toLowerCase()) {
+        issue(['account_binding', 'protocol_roles', 'hyperliquid', 'master'], 'the master account must be the bound EOA');
+    }
+    if (account.chainId !== HYPERLIQUID_L1_SIGNATURE_CHAIN_ID ||
+        value.payload.chain_id !== HYPERLIQUID_L1_SIGNATURE_CHAIN_ID ||
+        value.submission.chain_id !== HYPERLIQUID_L1_SIGNATURE_CHAIN_ID) {
+        issue(['payload', 'chain_id'], 'Hyperliquid L1 actions pin signature chain id 1337');
+    }
+    // The vault address lives in the SIGNED digest preimage, so the binding outside is only
+    // meaningful if the payload declares the same value.
+    if ((roles.vault_address?.toLowerCase() ?? null) !==
+        (value.payload.vault_address?.toLowerCase() ?? null)) {
+        issue(['account_binding', 'protocol_roles', 'hyperliquid', 'vault_address'], 'must equal the vault address declared in the payload');
+    }
+    if (value.payload.action.orders.some((leg) => leg.a !== roles.asset_id)) {
+        issue(['payload', 'action', 'orders'], 'every leg must name the bound asset id');
+    }
+    if (value.submission.artifact_id !== value.artifact_id) {
+        issue(['submission', 'artifact_id'], 'must match the envelope artifact_id');
+    }
+    // `expiresAfter` is the constructor's own freshness bound placed inside the signed digest, so the
+    // two must agree exactly; otherwise the envelope promises one deadline and the venue enforces
+    // another.
+    if (value.payload.expires_after !== Date.parse(value.valid_until)) {
+        issue(['payload', 'expires_after'], 'must equal valid_until in unix milliseconds: the venue enforces this deadline inside the signed digest');
+    }
+    if (!isArtifactFreshnessWellFormed(value.artifact_id, value.valid_until)) {
+        issue(['valid_until'], 'valid_until must follow the artifact_id construction time and stay within the freshness ceiling');
+    }
+});
+/**
+ * Every artifact this MCP produces. Operation is a literal on each branch, so a swap artifact can
+ * never satisfy the bridge branch or the reverse — the union widens what adapters accept without
+ * loosening either branch's binds.
+ */
+export const EXECUTION_ARTIFACT_SCHEMA = z.union([
+    EXECUTION_ENVELOPE_SCHEMA,
+    BRIDGE_EXECUTION_ENVELOPE_SCHEMA,
+    POLYMARKET_EXECUTION_ENVELOPE_SCHEMA,
+    HYPERLIQUID_EXECUTION_ENVELOPE_SCHEMA,
+]);
+/** The enumerated v1 bridge chains, surfaced for the tool description and for callers. */
+export const ENUMERATED_BRIDGE_CHAIN_IDS = Object.freeze(Object.keys(LIFI_CCTP_USDC_BY_CHAIN)
+    .map((chainId) => Number(chainId))
+    .sort((left, right) => left - right));
+export const EXECUTION_TOOL_DEFINITIONS = Object.freeze([
+    Object.freeze({
+        name: 'otto_prepare_swap',
+        title: 'Prepare an Otto-attributed LI.FI swap',
+        description: "Prepare, decode, and verify an unsigned same-chain EVM ERC20 swap construction aid for the caller-owned EOA or Safe. The envelope's valid_until bounds freshness and is committed to the artifact digest; the signer account nonce is the on-chain replay boundary, and this tool cannot guarantee single execution. Returns ordered allowance-reset, approval, and call steps only; never signs or submits.",
+        inputSchema: PREPARE_SWAP_INPUT_SCHEMA,
+        outputSchema: EXECUTION_ENVELOPE_SCHEMA,
+    }),
+    Object.freeze({
+        name: 'otto_prepare_bridge',
+        title: 'Prepare an Otto-attributed LI.FI cross-chain USDC bridge',
+        description: "Prepare, decode, and verify an unsigned cross-chain native-USDC bridge construction aid for the caller-owned EOA or Safe, over the enumerated v1 Circle-CCTP route set (Ethereum, Polygon, Base, Arbitrum, Avalanche); any other chain, token, or bridge route is refused by name. The envelope's valid_until bounds freshness and is committed to the artifact digest; the signer account nonce is the on-chain replay boundary, and this tool cannot guarantee single execution. Returns ordered allowance-reset, approval, and call steps on the source chain only; never signs or submits.",
+        inputSchema: PREPARE_BRIDGE_INPUT_SCHEMA,
+        outputSchema: BRIDGE_EXECUTION_ENVELOPE_SCHEMA,
+    }),
+    Object.freeze({
+        name: 'otto_prepare_polymarket_order',
+        title: 'Prepare an Otto-attributed Polymarket CLOB limit order',
+        description: "Prepare and verify an unsigned Polymarket CTF Exchange V2 limit order (GTC) for the caller-owned Polygon EOA, with Otto's builder code stamped inside the EIP-712 order struct and re-asserted on the exact digest the signer will sign. The price must be an exact multiple of the market's live minimum tick size and the size at or above its published minimum. The envelope's valid_until bounds freshness and is committed to the artifact digest; the exchange's own order hash is the replay boundary, and this tool cannot guarantee single execution. Returns order args and typed data only; never signs or submits, holds no CLOB credentials, and touches no collateral or allowance.",
+        inputSchema: PREPARE_POLYMARKET_ORDER_INPUT_SCHEMA,
+        outputSchema: POLYMARKET_EXECUTION_ENVELOPE_SCHEMA,
+    }),
+    Object.freeze({
+        name: 'otto_prepare_perp_order',
+        title: 'Prepare an unsigned Hyperliquid perp order L1 action',
+        description: "Prepare and verify an unsigned Hyperliquid perpetuals order (limit, with optional reduce-only take-profit and stop-loss triggers bundled as normalTpsl) for the caller-owned Hyperliquid account, returned as the canonical L1 action plus the exact EIP-712 Agent domain, struct, and connectionId recipe the caller's own signer needs. The asset id, size grid, and price grid come from the live perp universe: an unknown or delisted perp, a size finer than the asset's szDecimals, or a price off the venue's 5-significant-digit / (6 - szDecimals) decimal grid is refused by name rather than rounded to a different order. There is no market order — name your own aggressive limit price with 'Ioc'. Otto's builder attribution is spec'd and valueless today, so the action carries no builder field and the envelope says so. The nonce is chosen by the signer, never here; the envelope's valid_until is committed to the artifact digest AND placed inside the signed digest as expiresAfter, so the venue itself rejects a stale action, while the Hyperliquid signer nonce remains the replay boundary and this tool cannot guarantee single execution. This tool never signs or submits, holds no key, and derives no agent wallet.",
+        inputSchema: PREPARE_PERP_ORDER_INPUT_SCHEMA,
+        outputSchema: HYPERLIQUID_EXECUTION_ENVELOPE_SCHEMA,
+    }),
+]);
+export const EXECUTION_TOOL_DEFINITION_BY_NAME = new Map(EXECUTION_TOOL_DEFINITIONS.map((definition) => [definition.name, definition]));
+//# sourceMappingURL=execution-tool-definitions.js.map