otto-intel-mcp 0.1.0

package/dist/lifi-fee-assertions.js

@@ -0,0 +1,103 @@
+import { decodeAbiParameters, encodeAbiParameters, getAddress, parseAbiParameters, } from 'viem';
+import { attributedFeeAmount } from './execution-config.js';
+import { isExecutionRefusal, refuse } from './execution-errors.js';
+const FORWARD_FEES_BODY = parseAbiParameters('address token, (address recipient, uint256 amount)[] distributions');
+/** `FeeCollector.collectTokenFees(...)` — the only calldata a reviewed fee-forwarding leg may carry. */
+export const FORWARD_ERC20_FEES_SELECTOR = '0x332d746b';
+function attributionRefuse(message) {
+    return refuse('ATTRIBUTION_MISSING', message);
+}
+function argRegion(data) {
+    return `0x${data.slice(10)}`;
+}
+/**
+ * Decode a `collectTokenFees` body. Shared by the same-chain swap and cross-chain bridge
+ * constructors so the fund-critical attribution shape has exactly one implementation: two copies
+ * of this check would drift, and a drifted copy is an unattributed or over-charged payload.
+ */
+export function decodeFeeDistributions(callData) {
+    if (callData.slice(0, 10).toLowerCase() !== FORWARD_ERC20_FEES_SELECTOR) {
+        return attributionRefuse('LI.FI fee leg does not call forwardERC20Fees');
+    }
+    const args = argRegion(callData);
+    try {
+        const decoded = decodeAbiParameters(FORWARD_FEES_BODY, args);
+        if (encodeAbiParameters(FORWARD_FEES_BODY, decoded).toLowerCase() !== args.toLowerCase()) {
+            attributionRefuse('LI.FI fee calldata is non-canonical or carries trailing bytes');
+        }
+        const [token, distributions] = decoded;
+        if (distributions.length === 0 || distributions.length > 8) {
+            attributionRefuse('LI.FI fee calldata has an unexpected distribution count');
+        }
+        for (const distribution of distributions) {
+            if (getAddress(distribution.recipient) ===
+                getAddress('0x0000000000000000000000000000000000000000')) {
+                attributionRefuse('LI.FI fee calldata has a zero recipient');
+            }
+            if (distribution.amount <= 0n) {
+                attributionRefuse('LI.FI fee calldata has a non-positive amount');
+            }
+        }
+        return { token: getAddress(token), distributions };
+    }
+    catch (error) {
+        if (isExecutionRefusal(error))
+            throw error;
+        return attributionRefuse('LI.FI fee calldata could not be decoded');
+    }
+}
+/**
+ * Assert the decoded fee body carries exactly the versioned recipient set, the exact configured
+ * Otto amount, and an aggregate within the configured cap. Assert-what-you-built: this runs on the
+ * serialized calldata that is about to be returned, not on the values the constructor intended.
+ */
+export function assertFeeDistributionBody(input) {
+    const feeBody = decodeFeeDistributions(input.callData);
+    if (feeBody.token !== input.expectedToken) {
+        attributionRefuse('LI.FI fee-forwarding body names a different token');
+    }
+    const expectedOttoFee = attributedFeeAmount(input.grossAmount, input.config.lifiFee);
+    if (expectedOttoFee <= 0n) {
+        refuse('UNSUPPORTED_LIFI_ROUTE', 'input amount is too small to encode the configured Otto fee');
+    }
+    const allowedFeeRecipients = input.config.lifiAllowedFeeRecipients.map((recipient) => getAddress(recipient));
+    const allowedFeeRecipientSet = new Set(allowedFeeRecipients);
+    if (allowedFeeRecipients.length === 0 ||
+        allowedFeeRecipientSet.size !== allowedFeeRecipients.length ||
+        !allowedFeeRecipientSet.has(input.config.lifiFeeRecipient)) {
+        refuse('UNSUPPORTED_LIFI_ROUTE', 'LI.FI fee-recipient configuration is invalid');
+    }
+    const recipientCounts = new Map();
+    let aggregateFeeAmount = 0n;
+    for (const distribution of feeBody.distributions) {
+        const recipient = getAddress(distribution.recipient);
+        if (!allowedFeeRecipientSet.has(recipient)) {
+            attributionRefuse('LI.FI fee-forwarding body contains an unrecognized recipient');
+        }
+        recipientCounts.set(recipient, (recipientCounts.get(recipient) ?? 0) + 1);
+        aggregateFeeAmount += distribution.amount;
+    }
+    if (feeBody.distributions.length !== allowedFeeRecipients.length ||
+        allowedFeeRecipients.some((recipient) => recipientCounts.get(recipient) !== 1)) {
+        attributionRefuse('LI.FI fee-forwarding body does not match the versioned recipient set');
+    }
+    const ottoDistribution = feeBody.distributions.find((distribution) => getAddress(distribution.recipient) === input.config.lifiFeeRecipient);
+    if (ottoDistribution?.amount !== expectedOttoFee) {
+        attributionRefuse('LI.FI fee-forwarding body does not contain the exact configured Otto fee');
+    }
+    const aggregateFeeCap = attributedFeeAmount(input.grossAmount, input.config.lifiAggregateFeeCap);
+    if (aggregateFeeCap <= 0n) {
+        refuse('UNSUPPORTED_LIFI_ROUTE', 'input amount is too small to encode the configured aggregate fee cap');
+    }
+    if (aggregateFeeAmount > aggregateFeeCap) {
+        // Everything above has already passed: every recipient is in the versioned set, the set is
+        // complete and duplicate-free, and Otto's own distribution carries the exact configured
+        // amount. So an overage HERE is upstream take above the reviewed rate, never a missing or
+        // misdirected Otto fee — and it gets its own code for that reason. The cap has zero headroom
+        // over the live aggregate by design (see LIFI_FEE_CAP_EXCEEDED), so this is the branch a
+        // LI.FI repricing lands on, and it must degrade loudly under its own name rather than
+        // masquerading as a fee-integrity failure on whatever watches these refusals.
+        refuse('LIFI_FEE_CAP_EXCEEDED', `LI.FI fee body distributes ${aggregateFeeAmount} against the configured cap of ${aggregateFeeCap} on a gross of ${input.grossAmount}; the Otto attribution is exact, so the overage is upstream take`);
+    }
+}
+//# sourceMappingURL=lifi-fee-assertions.js.map

package/dist/lifi-swap-assertions.d.ts

@@ -0,0 +1,32 @@
+import { type Address, type Hex } from 'viem';
+import { type ExecutionServiceConfig } from './execution-config.js';
+import type { AccountProfile, ExecutionAssertion } from './execution-types.js';
+import { FORWARD_ERC20_FEES_SELECTOR } from './lifi-fee-assertions.js';
+import type { LiFiQuote } from './lifi-execution-client.js';
+export declare const LIFI_SWAP_SELECTORS: Readonly<{
+    singleErc20ToErc20: Hex;
+    multipleErc20ToErc20: Hex;
+}>;
+/** Re-exported so existing importers keep one selector constant across both LI.FI constructors. */
+export { FORWARD_ERC20_FEES_SELECTOR };
+export interface LiFiSwapAssertionInput {
+    readonly quote: LiFiQuote;
+    readonly profile: AccountProfile;
+    readonly chainId: number;
+    readonly fromToken: Address;
+    readonly toToken: Address;
+    readonly fromAmount: bigint;
+    readonly maxSlippageBps: number;
+    readonly minAmountOut?: bigint;
+    readonly config: ExecutionServiceConfig;
+}
+export interface AssertedLiFiSwap {
+    readonly approvalSpender: Address;
+    readonly transaction: {
+        readonly to: Address;
+        readonly value: '0';
+        readonly data: Hex;
+    };
+    readonly assertions: readonly ExecutionAssertion[];
+}
+export declare function decodeAndAssertLiFiSwap(input: LiFiSwapAssertionInput): AssertedLiFiSwap;

package/dist/lifi-swap-assertions.js

@@ -0,0 +1,214 @@
+import { decodeAbiParameters, encodeAbiParameters, getAddress, parseAbiParameters, } from 'viem';
+import { LIFI_DIAMOND_ADDRESS, isReviewedLiFiFeeForwarder, reviewedLiFiFeeForwarders, unreviewedFeeForwarderMessage, LIFI_INTEGRATOR, } from './execution-config.js';
+import { isExecutionRefusal, refuse } from './execution-errors.js';
+import { assertFeeDistributionBody, FORWARD_ERC20_FEES_SELECTOR, } from './lifi-fee-assertions.js';
+const SWAP_DATA_TUPLE = '(address callTo, address approveTo, address sendingAssetId, address receivingAssetId, uint256 fromAmount, bytes callData, bool requiresDeposit)';
+const LIFI_SINGLE_PARAMS = parseAbiParameters(`bytes32 _transactionId, string _integrator, string _referrer, address _receiver, uint256 _minAmount, ${SWAP_DATA_TUPLE} _swapData`);
+const LIFI_MULTIPLE_PARAMS = parseAbiParameters(`bytes32 _transactionId, string _integrator, string _referrer, address _receiver, uint256 _minAmount, ${SWAP_DATA_TUPLE}[] _swapData`);
+export const LIFI_SWAP_SELECTORS = Object.freeze({
+    singleErc20ToErc20: '0x4666fc80',
+    multipleErc20ToErc20: '0x5fd9ae2e',
+});
+/** Re-exported so existing importers keep one selector constant across both LI.FI constructors. */
+export { FORWARD_ERC20_FEES_SELECTOR };
+function quoteRefuse(message) {
+    return refuse('LIFI_QUOTE_INVALID', message);
+}
+function attributionRefuse(message) {
+    return refuse('ATTRIBUTION_MISSING', message);
+}
+function asAddress(value, field) {
+    if (typeof value !== 'string')
+        quoteRefuse(`${field} is missing`);
+    try {
+        return getAddress(value);
+    }
+    catch {
+        return quoteRefuse(`${field} is not a valid EVM address`);
+    }
+}
+function positiveBigInt(value, field) {
+    if (typeof value !== 'string' || !/^[1-9]\d*$/.test(value)) {
+        return quoteRefuse(`${field} must be a positive decimal integer`);
+    }
+    return BigInt(value);
+}
+function transactionData(value) {
+    if (typeof value !== 'string' || !/^0x(?:[0-9a-fA-F]{2}){4,}$/.test(value)) {
+        return quoteRefuse('transaction calldata is missing or malformed');
+    }
+    return value;
+}
+function argRegion(data) {
+    return `0x${data.slice(10)}`;
+}
+function decodeSwap(data) {
+    const selector = data.slice(0, 10).toLowerCase();
+    const args = argRegion(data);
+    try {
+        if (selector === LIFI_SWAP_SELECTORS.singleErc20ToErc20) {
+            const decoded = decodeAbiParameters(LIFI_SINGLE_PARAMS, args);
+            if (encodeAbiParameters(LIFI_SINGLE_PARAMS, decoded).toLowerCase() !== args.toLowerCase()) {
+                quoteRefuse('single-swap calldata is non-canonical or carries trailing bytes');
+            }
+            const [, integrator, , receiver, minAmount, leg] = decoded;
+            return { integrator, receiver: getAddress(receiver), minAmount, legs: [leg] };
+        }
+        if (selector === LIFI_SWAP_SELECTORS.multipleErc20ToErc20) {
+            const decoded = decodeAbiParameters(LIFI_MULTIPLE_PARAMS, args);
+            if (encodeAbiParameters(LIFI_MULTIPLE_PARAMS, decoded).toLowerCase() !== args.toLowerCase()) {
+                quoteRefuse('multiple-swap calldata is non-canonical or carries trailing bytes');
+            }
+            const [, integrator, , receiver, minAmount, legs] = decoded;
+            return { integrator, receiver: getAddress(receiver), minAmount, legs };
+        }
+    }
+    catch (error) {
+        if (isExecutionRefusal(error))
+            throw error;
+        return quoteRefuse('transaction calldata could not be decoded as GenericSwapV3 ERC20-to-ERC20');
+    }
+    return refuse('UNSUPPORTED_LIFI_ROUTE', `LI.FI selector ${selector} is not supported by the v1 ERC20-to-ERC20 route set`);
+}
+function assertQuoteBinding(input) {
+    const { action, estimate, transactionRequest } = input.quote;
+    if (action.fromChainId !== input.chainId || action.toChainId !== input.chainId) {
+        quoteRefuse('LI.FI quote is not bound to the requested same chain');
+    }
+    if (action.fromAmount !== input.fromAmount.toString()) {
+        quoteRefuse('LI.FI quote input amount does not match the intent');
+    }
+    if (asAddress(action.fromToken.address, 'quote input token') !== input.fromToken ||
+        asAddress(action.toToken.address, 'quote output token') !== input.toToken) {
+        quoteRefuse('LI.FI quote token pair does not match the intent');
+    }
+    const account = getAddress(input.profile.address);
+    if (asAddress(action.fromAddress, 'quote sender') !== account ||
+        asAddress(action.toAddress, 'quote receiver') !== account) {
+        return refuse('ACCOUNT_BINDING_MISMATCH', 'LI.FI quote sender or receiver is not the bound account');
+    }
+    if (Math.round(action.slippage * 10_000) !== input.maxSlippageBps) {
+        quoteRefuse('LI.FI quote slippage does not match the requested bound');
+    }
+    const approvalSpender = asAddress(estimate.approvalAddress, 'LI.FI approval target');
+    const transactionTarget = asAddress(transactionRequest.to, 'LI.FI transaction target');
+    if (approvalSpender !== LIFI_DIAMOND_ADDRESS || transactionTarget !== LIFI_DIAMOND_ADDRESS) {
+        quoteRefuse('LI.FI approval or transaction target is not the reviewed Diamond');
+    }
+    if (transactionRequest.from !== undefined &&
+        asAddress(transactionRequest.from, 'LI.FI transaction sender') !== account) {
+        return refuse('ACCOUNT_BINDING_MISMATCH', 'LI.FI transaction sender is not the bound account');
+    }
+    let transactionValue;
+    try {
+        transactionValue = BigInt(transactionRequest.value);
+    }
+    catch {
+        return quoteRefuse('LI.FI transaction value is invalid');
+    }
+    if (transactionValue !== 0n) {
+        quoteRefuse('ERC20-input LI.FI swap unexpectedly transfers native value');
+    }
+    return {
+        approvalSpender,
+        transactionTarget,
+        transactionValue,
+        data: transactionData(transactionRequest.data),
+    };
+}
+export function decodeAndAssertLiFiSwap(input) {
+    if (input.profile.kind !== 'eoa' && input.profile.kind !== 'safe') {
+        return refuse('UNSUPPORTED_ACCOUNT_PROFILE', 'only EOA and Safe account profiles are supported');
+    }
+    if (input.profile.chainId !== input.chainId) {
+        return refuse('ACCOUNT_BINDING_MISMATCH', 'account profile chain does not match swap chain');
+    }
+    const feeForwarders = reviewedLiFiFeeForwarders(input.chainId);
+    if (!feeForwarders) {
+        return refuse('UNSUPPORTED_LIFI_ROUTE', 'chain is outside the reviewed LI.FI v1 route set');
+    }
+    const boundQuote = assertQuoteBinding(input);
+    const decoded = decodeSwap(boundQuote.data);
+    if (decoded.legs.length === 0)
+        quoteRefuse('LI.FI calldata has no swap legs');
+    if (decoded.integrator !== LIFI_INTEGRATOR) {
+        attributionRefuse('LI.FI calldata does not carry the exact Otto integrator');
+    }
+    if (getAddress(decoded.receiver) !== getAddress(input.profile.address)) {
+        return refuse('ACCOUNT_BINDING_MISMATCH', 'LI.FI calldata receiver is not the bound account');
+    }
+    let deposited = 0n;
+    for (const leg of decoded.legs) {
+        if (leg.requiresDeposit) {
+            if (getAddress(leg.sendingAssetId) !== input.fromToken) {
+                quoteRefuse('LI.FI calldata contains a foreign-token deposit leg');
+            }
+            deposited += leg.fromAmount;
+        }
+    }
+    if (deposited !== input.fromAmount) {
+        quoteRefuse('LI.FI calldata deposit amount does not equal the exact intent amount');
+    }
+    const lastLeg = decoded.legs[decoded.legs.length - 1];
+    if (!lastLeg || getAddress(lastLeg.receivingAssetId) !== input.toToken) {
+        quoteRefuse('LI.FI calldata output token does not match the intent');
+    }
+    // Classify fee-capable legs before checking their exact shape. Otherwise a second executable
+    // forwardERC20Fees call can evade the complete recipient-set and aggregate-cap checks merely by
+    // naming a different approveTo target.
+    const feeLegs = decoded.legs.filter((leg) => isReviewedLiFiFeeForwarder(input.chainId, leg.callTo) ||
+        leg.callData.slice(0, 10).toLowerCase() === FORWARD_ERC20_FEES_SELECTOR);
+    if (feeLegs.length !== 1) {
+        attributionRefuse('LI.FI calldata does not contain exactly one reviewed fee-forwarding leg');
+    }
+    const feeLeg = feeLegs[0];
+    // The drift alarm: an unreviewed collector is refused BY ADDRESS, so an upstream rollout reads as
+    // a loud "review and add" instead of a dark rail.
+    if (!isReviewedLiFiFeeForwarder(input.chainId, feeLeg.callTo) ||
+        !isReviewedLiFiFeeForwarder(input.chainId, feeLeg.approveTo) ||
+        getAddress(feeLeg.callTo) !== getAddress(feeLeg.approveTo)) {
+        attributionRefuse(unreviewedFeeForwarderMessage(input.chainId, feeLeg.callTo, feeLeg.approveTo));
+    }
+    if (feeLeg.callData.slice(0, 10).toLowerCase() !== FORWARD_ERC20_FEES_SELECTOR ||
+        !feeLeg.requiresDeposit ||
+        getAddress(feeLeg.sendingAssetId) !== input.fromToken ||
+        getAddress(feeLeg.receivingAssetId) !== input.fromToken ||
+        feeLeg.fromAmount !== input.fromAmount) {
+        attributionRefuse('LI.FI fee-forwarding leg is not bound to the exact input token and amount');
+    }
+    assertFeeDistributionBody({
+        callData: feeLeg.callData,
+        expectedToken: input.fromToken,
+        grossAmount: input.fromAmount,
+        config: input.config,
+    });
+    const quotedOutput = positiveBigInt(input.quote.estimate.toAmount, 'LI.FI quoted output');
+    const quotedMinimum = positiveBigInt(input.quote.estimate.toAmountMin, 'LI.FI quoted minimum output');
+    const slippageFloor = (quotedOutput * BigInt(10_000 - input.maxSlippageBps)) / 10000n;
+    if (decoded.minAmount !== quotedMinimum || decoded.minAmount < slippageFloor) {
+        quoteRefuse('LI.FI calldata minimum output is inconsistent with the slippage bound');
+    }
+    if (input.minAmountOut !== undefined && decoded.minAmount < input.minAmountOut) {
+        quoteRefuse('LI.FI calldata minimum output is below the caller constraint');
+    }
+    return Object.freeze({
+        approvalSpender: boundQuote.approvalSpender,
+        transaction: Object.freeze({
+            to: boundQuote.transactionTarget,
+            value: '0',
+            data: boundQuote.data,
+        }),
+        assertions: Object.freeze([
+            Object.freeze({ id: 'lifi_integrator_exact', result: 'passed' }),
+            Object.freeze({ id: 'lifi_fee_recipient_exact', result: 'passed' }),
+            Object.freeze({ id: 'lifi_fee_amount_exact', result: 'passed' }),
+            Object.freeze({ id: 'lifi_fee_recipient_set_versioned', result: 'passed' }),
+            Object.freeze({ id: 'lifi_fee_aggregate_cap', result: 'passed' }),
+            Object.freeze({ id: 'lifi_receiver_account_bound', result: 'passed' }),
+            Object.freeze({ id: 'lifi_min_out_slippage_bound', result: 'passed' }),
+            Object.freeze({ id: 'lifi_token_amount_bound', result: 'passed' }),
+            Object.freeze({ id: 'lifi_targets_value_bound', result: 'passed' }),
+        ]),
+    });
+}
+//# sourceMappingURL=lifi-swap-assertions.js.map

package/dist/local-config.d.ts

@@ -0,0 +1,9 @@
+import type { Hex } from 'viem';
+export interface LocalX402Config {
+    readonly privateKey: Hex;
+    readonly baseUrl: string;
+    readonly rpcUrl?: string;
+    readonly timeoutMs: number;
+}
+export declare function assertAllowedX402BaseUrl(raw: string): string;
+export declare function loadLocalX402Config(env?: NodeJS.ProcessEnv): LocalX402Config;

package/dist/local-config.js

@@ -0,0 +1,45 @@
+function requireNonBlank(env, name) {
+    const value = env[name]?.trim();
+    if (!value)
+        throw new Error(`${name} is required`);
+    return value;
+}
+function positiveInteger(raw, fallback, name) {
+    if (raw === undefined || raw.trim() === '')
+        return fallback;
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new Error(`${name} must be a positive integer`);
+    return value;
+}
+function isLoopback(hostname) {
+    return (hostname === 'localhost' ||
+        hostname === '127.0.0.1' ||
+        hostname === '::1' ||
+        hostname === '[::1]');
+}
+export function assertAllowedX402BaseUrl(raw) {
+    const url = new URL(raw);
+    if (url.username || url.password)
+        throw new Error('X402_BASE_URL must not contain credentials');
+    const isOfficial = url.protocol === 'https:' && url.origin === 'https://x402.ottoai.services';
+    const isLocal = ['http:', 'https:'].includes(url.protocol) && isLoopback(url.hostname);
+    if (!isOfficial && !isLocal) {
+        throw new Error('X402_BASE_URL must be https://x402.ottoai.services or a loopback test server');
+    }
+    return url.toString().replace(/\/$/, '');
+}
+export function loadLocalX402Config(env = process.env) {
+    const rawKey = requireNonBlank(env, 'X402_PRIVATE_KEY');
+    const normalizedKey = rawKey.startsWith('0x') ? rawKey : `0x${rawKey}`;
+    if (!/^0x[a-fA-F0-9]{64}$/.test(normalizedKey)) {
+        throw new Error('X402_PRIVATE_KEY must be a 32-byte hexadecimal private key');
+    }
+    return {
+        privateKey: normalizedKey,
+        baseUrl: assertAllowedX402BaseUrl(env.X402_BASE_URL?.trim() || 'https://x402.ottoai.services'),
+        rpcUrl: env.X402_RPC_URL?.trim() || undefined,
+        timeoutMs: positiveInteger(env.X402_TIMEOUT_MS, 30_000, 'X402_TIMEOUT_MS'),
+    };
+}
+//# sourceMappingURL=local-config.js.map

package/dist/mcp-server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { IntelDataSource } from './data-source.js';
+import type { ExecutionToolRuntime } from './execution-tools.js';
+export declare function createIntelMcpServer(dataSource: IntelDataSource, executionRuntime?: ExecutionToolRuntime): McpServer;

package/dist/mcp-server.js

@@ -0,0 +1,44 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { mapToolError } from './errors.js';
+import { registerExecutionTools } from './execution-registration.js';
+import { TOOL_DEFINITIONS } from './tool-definitions.js';
+const READ_ONLY_ANNOTATIONS = Object.freeze({
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+});
+function stringify(value) {
+    return JSON.stringify(value, (_key, item) => typeof item === 'bigint' ? item.toString() : item);
+}
+async function callDefinition(dataSource, definition, rawInput) {
+    const input = definition.inputSchema.parse(rawInput);
+    try {
+        const result = await dataSource.read(definition, input);
+        return {
+            content: [{ type: 'text', text: stringify(result) }],
+        };
+    }
+    catch (error) {
+        return mapToolError(error);
+    }
+}
+export function createIntelMcpServer(dataSource, executionRuntime) {
+    const server = new McpServer({
+        name: 'otto-intel',
+        title: 'Otto Intel',
+        version: '0.1.0',
+    });
+    for (const definition of TOOL_DEFINITIONS) {
+        server.registerTool(definition.name, {
+            title: definition.title,
+            description: definition.description,
+            inputSchema: definition.inputSchema,
+            annotations: READ_ONLY_ANNOTATIONS,
+        }, (input) => callDefinition(dataSource, definition, input));
+    }
+    if (executionRuntime)
+        registerExecutionTools(server, executionRuntime);
+    return server;
+}
+//# sourceMappingURL=mcp-server.js.map

package/dist/polymarket-clob-client.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import type { Hex } from 'viem';
+import { type ExecutionServiceConfig, type PolymarketTickSize } from './execution-config.js';
+/** The live `/markets/{condition_id}` body, as captured in `test/fixtures/polymarket-market-*.json`. */
+export declare const POLYMARKET_MARKET_RESPONSE_SCHEMA: z.ZodObject<{
+    condition_id: z.ZodString;
+    minimum_tick_size: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    minimum_order_size: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    neg_risk: z.ZodOptional<z.ZodBoolean>;
+    accepting_orders: z.ZodBoolean;
+    active: z.ZodBoolean;
+    closed: z.ZodBoolean;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    enable_order_book: z.ZodBoolean;
+    tokens: z.ZodArray<z.ZodObject<{
+        token_id: z.ZodString;
+        outcome: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const POLYMARKET_TOKEN_MARKET_RESPONSE_SCHEMA: z.ZodObject<{
+    condition_id: z.ZodString;
+}, z.core.$loose>;
+/** The live `/fees/builder-fees/{code}` body: the value source for the ruled builder rates (§8). */
+export declare const POLYMARKET_BUILDER_FEES_RESPONSE_SCHEMA: z.ZodObject<{
+    code: z.ZodString;
+    builder_maker_fee_rate_bps: z.ZodNumber;
+    builder_taker_fee_rate_bps: z.ZodNumber;
+    enabled: z.ZodBoolean;
+}, z.core.$loose>;
+export interface PolymarketMarketMetadata {
+    readonly tokenId: string;
+    readonly conditionId: string;
+    readonly tickSize: PolymarketTickSize;
+    /** Minimum order size in shares, as the venue publishes it; never a value this repo invents. */
+    readonly minimumOrderSize: number;
+    readonly negRisk: boolean;
+    readonly acceptingOrders: boolean;
+    readonly active: boolean;
+    readonly closed: boolean;
+    readonly orderBookEnabled: boolean;
+}
+export interface PolymarketBuilderFeeRates {
+    readonly code: string;
+    readonly makerBps: number;
+    readonly takerBps: number;
+    readonly enabled: boolean;
+}
+export interface PolymarketClobClient {
+    getMarketMetadata(tokenId: string, signal?: AbortSignal): Promise<PolymarketMarketMetadata>;
+    getBuilderFeeRates(builderCode: Hex, signal?: AbortSignal): Promise<PolymarketBuilderFeeRates>;
+}
+/**
+ * Map a live market body onto the metadata the constructor needs, refusing every shape the
+ * constructor cannot act on. Shared by the REST client and the recorded-fixture loader, so the
+ * assertions in tests run over the same parse the network path uses.
+ */
+export declare function polymarketMarketMetadata(raw: unknown, tokenId: string): PolymarketMarketMetadata;
+/**
+ * The live builder-registry row for exactly the expected code. A row for a different code is
+ * refused rather than trusted: the whole point of the read is to bind Otto's own attribution.
+ */
+export declare function polymarketBuilderFeeRates(raw: unknown, expectedCode: Hex): PolymarketBuilderFeeRates;
+export declare function buildPolymarketMarketByTokenUrl(tokenId: string, config: Pick<ExecutionServiceConfig, 'polymarketClobBaseUrl'>): URL;
+export declare function buildPolymarketMarketUrl(conditionId: string, config: Pick<ExecutionServiceConfig, 'polymarketClobBaseUrl'>): URL;
+export declare function buildPolymarketBuilderFeesUrl(builderCode: Hex, config: Pick<ExecutionServiceConfig, 'polymarketClobBaseUrl'>): URL;
+export declare class RestPolymarketClobClient implements PolymarketClobClient {
+    private readonly config;
+    private readonly fetchImpl;
+    constructor(config: ExecutionServiceConfig, fetchImpl?: typeof fetch);
+    getMarketMetadata(tokenId: string, signal?: AbortSignal): Promise<PolymarketMarketMetadata>;
+    getBuilderFeeRates(builderCode: Hex, signal?: AbortSignal): Promise<PolymarketBuilderFeeRates>;
+    private getJson;
+}