@coinrithm/mcp-trading 0.1.8 → 0.3.0

package/dist/agent/types.d.ts

@@ -0,0 +1,286 @@
+import { IndicatorSet } from "./indicators.js";
+export declare const SPEC_VERSION = "coinrithm.agent.v1";
+export type Venue = "spot" | "futures" | "pm";
+export declare const VENUES: readonly Venue[];
+export declare const ACTION_TYPES: readonly ["futures_open", "futures_close", "futures_set_sltp", "spot_order", "spot_cancel", "pm_open"];
+export type ActionType = (typeof ACTION_TYPES)[number];
+export type ProviderName = "anthropic" | "openai" | "groq" | "nvidia" | "openai-compatible";
+export declare const PROVIDERS: readonly ProviderName[];
+export interface ModelConfig {
+    provider: ProviderName;
+    name: string;
+    baseUrl?: string;
+}
+export interface TriggerConfig {
+    cadence: string;
+    timezone?: string;
+}
+export interface RiskConfig {
+    maxLeverage: number;
+    perTradeMarginMusd: number;
+    maxConcurrentPositions: number;
+    requireStopLoss: boolean;
+    watchlist: string[];
+    blocklist?: string[];
+}
+export interface LimitsConfig {
+    maxTradesPerDay: number;
+    maxWritesPerCycle: number;
+    maxDailyLossMusd: number;
+    maxOpenMarginMusd: number;
+}
+export interface AbstentionConfig {
+    onStaleData: boolean;
+    onWeakSignal: boolean;
+    onMissingQuote: boolean;
+    onInsufficientBalance: boolean;
+    minConfidence: number;
+}
+export interface SyncConfig {
+    requirePollBeforeWrite: boolean;
+}
+export interface KillSwitchConfig {
+    maxDrawdownMusd: number;
+    maxConsecutiveRejects: number;
+    maxConsecutiveModelFailures: number;
+    onRateLimitPressure: boolean;
+}
+export declare const OBJECTIVE_PRIMARIES: readonly ["realized_pnl", "risk_adjusted", "drawdown_control", "calibration"];
+export type ObjectivePrimary = (typeof OBJECTIVE_PRIMARIES)[number];
+export interface ObjectiveConfig {
+    primary: ObjectivePrimary;
+    secondary: string[];
+    horizon?: string;
+}
+export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators"];
+export type Capability = (typeof ALLOWED_CAPABILITIES)[number];
+export interface AgentSpec {
+    name: string;
+    description: string;
+    spec: string;
+    trigger: TriggerConfig;
+    model?: ModelConfig;
+    venues: Venue[];
+    risk: RiskConfig;
+    limits: LimitsConfig;
+    abstention: AbstentionConfig;
+    sync: SyncConfig;
+    killSwitch: KillSwitchConfig;
+    objective?: ObjectiveConfig;
+    capabilities: Capability[];
+}
+export interface ParsedSkill {
+    spec: AgentSpec;
+    body: string;
+    raw: Record<string, unknown>;
+}
+export interface ValidationResult {
+    valid: boolean;
+    code?: string;
+    reason?: string;
+}
+export declare const ok: () => ValidationResult;
+export declare const fail: (code: string, reason: string) => ValidationResult;
+export interface Freshness {
+    status: string;
+    ageSeconds?: number;
+}
+export interface WatchEntry {
+    symbol: string;
+    coinId: string | null;
+    name?: string;
+    priceUsd?: number;
+    change1h?: number;
+    change24h?: number;
+    change7d?: number;
+    freshness?: Freshness;
+    indicators?: IndicatorSet;
+}
+export interface OpenPosition {
+    venue: Venue;
+    id: number;
+    coinId?: string;
+    symbol?: string;
+    side?: string;
+    status?: string;
+    marginMusd?: number;
+    unrealizedPnlMusd?: number;
+}
+export interface SpotOrder {
+    id: number;
+    coinId?: string;
+    symbol?: string;
+    side?: string;
+    orderType?: string;
+    quantity?: number;
+    status?: string;
+}
+export interface PmPosition {
+    id: number;
+    source?: string;
+    slug?: string;
+    outcomeExternalMarketId?: string;
+    stakeMusd?: number;
+    status?: string;
+}
+export interface PmMarket {
+    source: string;
+    slug: string;
+    outcomeExternalMarketId: string;
+    title?: string;
+    freshness?: Freshness;
+}
+export interface Observation {
+    asOf: string;
+    scopes: string[];
+    cashAvailableMusd: number | null;
+    equityMusd: number | null;
+    openPositions: OpenPosition[];
+    openOrders: SpotOrder[];
+    pmPositions: PmPosition[];
+    pmMarkets: PmMarket[];
+    watch: WatchEntry[];
+    syncCursor: string | null;
+    newClosedTrades: Array<Record<string, unknown>>;
+    polledBeforeWrite: boolean;
+}
+export type ProposedAction = {
+    type: "futures_open";
+    symbol: string;
+    side: "long" | "short";
+    leverage: number;
+    marginMusd: number;
+    stopLossPrice?: number | null;
+    takeProfitPrice?: number | null;
+    confidence?: number;
+    rationaleSummary?: string;
+} | {
+    type: "futures_close";
+    positionId: number;
+    fraction?: number;
+    confidence?: number;
+    rationaleSummary?: string;
+} | {
+    type: "futures_set_sltp";
+    positionId: number;
+    stopLossPrice?: number | null;
+    takeProfitPrice?: number | null;
+} | {
+    type: "spot_order";
+    symbol: string;
+    side: "buy" | "sell";
+    orderType: "market" | "limit" | "stop";
+    quantity: number;
+    limitPrice?: number;
+    stopPrice?: number;
+    confidence?: number;
+    rationaleSummary?: string;
+} | {
+    type: "spot_cancel";
+    orderId: number;
+} | {
+    type: "pm_open";
+    source: string;
+    slug: string;
+    outcomeExternalMarketId: string;
+    stakeMusd: number;
+    confidence?: number;
+    rationaleSummary?: string;
+};
+export type ActionVenue = Venue;
+export declare function actionVenue(a: ProposedAction): ActionVenue;
+export declare function isWriteAction(a: ProposedAction): boolean;
+export declare function isOpenAction(a: ProposedAction): a is Extract<ProposedAction, {
+    type: "futures_open" | "spot_order" | "pm_open";
+}>;
+export declare function spotBuyCost(action: Extract<ProposedAction, {
+    type: "spot_order";
+}>, quote?: QuoteEvidence): number | undefined;
+export interface Decision {
+    decision: "skip" | "act";
+    reason?: string;
+    confidence?: number;
+    actions: ProposedAction[];
+}
+export interface QuoteEvidence {
+    eligible: boolean;
+    blockReasons?: unknown;
+    entryPrice?: number;
+    liquidationPrice?: number;
+    executionPrice?: number;
+    estimatedCostMusd?: number;
+    freshness?: Freshness;
+}
+export interface RunState {
+    runId: string;
+    cyclesRun: number;
+    writesToday: number;
+    realizedPnlMusd: number;
+    peakRealizedMusd: number;
+    consecutiveRejectCycles: number;
+    consecutiveModelFailures: number;
+    rateLimitHits: number;
+    disabled: boolean;
+    disabledReason?: string;
+    dayKey: string;
+    cursor: string | null;
+    seen: string[];
+    realizedPnlTodayMusd: number;
+    consecutiveExecFailures: number;
+    intentSeq: Record<string, number>;
+}
+export interface AgentTrace {
+    runId?: string;
+    decisionId?: string;
+    strategyLabel?: string;
+    confidence?: number;
+    rationaleSummary?: string;
+}
+export interface ApiResult {
+    ok: boolean;
+    status: number;
+    data: unknown;
+    retryAfterSeconds?: number;
+    rateLimitRemaining?: number;
+    ledgerEventId?: string | null;
+}
+export interface PlannedAction {
+    action: ProposedAction;
+    accepted: boolean;
+    code?: string;
+    reason?: string;
+    quote?: QuoteEvidence;
+    executed?: boolean;
+    result?: unknown;
+}
+export interface CycleResult {
+    decision: "skip" | "act";
+    skipReason?: string;
+    planned: PlannedAction[];
+    modelFailed?: boolean;
+    disabled?: boolean;
+    disabledReason?: string;
+    live: boolean;
+}
+export interface ResolveIssue {
+    code: string;
+    message: string;
+    path?: string;
+}
+export interface Provenance {
+    sources: Record<string, string>;
+    mergeOrder: string[];
+    includeOrder: string[];
+}
+export interface ResolvedAgent {
+    inputPath: string;
+    isDirectory: boolean;
+    rawFrontmatter: Record<string, unknown>;
+    mergedProse: string;
+    proseParts: Array<{
+        source: string;
+        text: string;
+    }>;
+    provenance: Provenance;
+    contentHashes: Record<string, string>;
+}

package/dist/agent/types.js

@@ -0,0 +1,88 @@
+// Core types for the CoinRithm public agent runner.
+//
+// An "agent" is a single SKILL.md: machine-read frontmatter (the AgentSpec
+// types here) plus a plain-language strategy body. The runner reads the spec,
+// wakes on cadence, asks a model for proposed actions, validates them against
+// these caps, and acts via the CoinRithm paper API. Nothing here touches real
+// money.
+export const SPEC_VERSION = "coinrithm.agent.v1";
+export const VENUES = ["spot", "futures", "pm"];
+// The runner's live action vocabulary — the capability set the drift guard
+// checks authored prose against. MUST mirror the ProposedAction union below and
+// the zod schema in decision.ts. A test ("ACTION_TYPES stays in lockstep with
+// the decision schema", capabilityGuard.test.ts) derives the literal set from
+// decision.ts's actionSchema and asserts equality, so the two cannot drift.
+export const ACTION_TYPES = [
+    "futures_open",
+    "futures_close",
+    "futures_set_sltp",
+    "spot_order",
+    "spot_cancel",
+    "pm_open",
+];
+export const PROVIDERS = [
+    "anthropic",
+    "openai",
+    "groq",
+    "nvidia",
+    "openai-compatible",
+];
+// What the agent declares it is optimizing for — so two similar-looking agents
+// are distinguishable and the scorecard/Arena can read intent.
+export const OBJECTIVE_PRIMARIES = [
+    "realized_pnl",
+    "risk_adjusted",
+    "drawdown_control",
+    "calibration",
+];
+// Opt-in capabilities beyond CoinRithm market reads + paper execution.
+// RESERVED in v1: declared + validated here, wired into the runner in a later
+// slice. `websearch` = external lookups (an injection surface + a cost — it can
+// inform reasoning but NEVER widen a cap, since caps live in the runner);
+// `indicators` = runner-computed RSI/MACD/etc. fed into the observation.
+export const ALLOWED_CAPABILITIES = ["websearch", "indicators"];
+export const ok = () => ({ valid: true });
+export const fail = (code, reason) => ({
+    valid: false,
+    code,
+    reason,
+});
+export function actionVenue(a) {
+    if (a.type.startsWith("futures"))
+        return "futures";
+    if (a.type.startsWith("spot"))
+        return "spot";
+    return "pm";
+}
+export function isWriteAction(a) {
+    // Every proposed action mutates state (set-sltp/cancel included). The model
+    // never proposes a read; reads are the runner's job during observe.
+    return true;
+}
+export function isOpenAction(a) {
+    return (a.type === "futures_open" || a.type === "spot_order" || a.type === "pm_open");
+}
+// Gross mUSD a spot BUY consumes. The validator (per-trade cap + balance gate)
+// and the runner (running-cash decrement) BOTH size with this one function so
+// they can never diverge. Sizing: limit -> limitPrice*qty, stop -> stopPrice*qty,
+// market -> the server-computed `estimatedCostMusd` (preferred) or
+// executionPrice*qty. Returns undefined when no price is available (e.g. an
+// unpriced market quote) so callers FAIL CLOSED instead of treating it as $0.
+export function spotBuyCost(action, quote) {
+    if (action.orderType === "limit") {
+        return typeof action.limitPrice === "number"
+            ? action.limitPrice * action.quantity
+            : undefined;
+    }
+    if (action.orderType === "stop") {
+        return typeof action.stopPrice === "number"
+            ? action.stopPrice * action.quantity
+            : undefined;
+    }
+    // market: prefer the server's gross notional, else derive from the fill price.
+    if (typeof quote?.estimatedCostMusd === "number")
+        return quote.estimatedCostMusd;
+    return typeof quote?.executionPrice === "number"
+        ? quote.executionPrice * action.quantity
+        : undefined;
+}

package/dist/agent/util.d.ts

@@ -0,0 +1,13 @@
+export declare const sleep: (ms: number) => Promise<void>;
+export declare function parseCadenceMs(cadence: unknown): number | null;
+export declare function dayKey(d?: Date): string;
+export declare function envFlag(value: string | undefined): boolean;
+export declare function scanForSecrets(value: unknown, pathPrefix?: string, findings?: string[]): string[];
+export declare function shortId(): string;
+export declare function normalizeContent(text: string): string;
+export declare function sha256(text: string): string;
+export declare function toPosix(p: string): string;
+export declare function isPathInside(parent: string, child: string): boolean;
+export declare function boundTail(text: string, maxLines: number, maxBytes: number): string;
+export declare function stableStringify(value: unknown): string;
+export declare function sortDeep(value: unknown): unknown;

package/dist/agent/util.js

@@ -0,0 +1,116 @@
+// Small dependency-free helpers shared across the runner.
+import { createHash } from "node:crypto";
+import { resolve as resolvePath, relative as relativePath, isAbsolute } from "node:path";
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Parse a cadence string ("30s", "15m", "1h", "4h", "1d") to milliseconds.
+// Returns null for anything unparseable so the skill validator can reject it.
+export function parseCadenceMs(cadence) {
+    if (typeof cadence !== "string")
+        return null;
+    const m = /^\s*(\d+)\s*(s|m|h|d)\s*$/i.exec(cadence);
+    if (!m)
+        return null;
+    const n = Number(m[1]);
+    if (!Number.isFinite(n) || n <= 0)
+        return null;
+    const unit = m[2].toLowerCase();
+    const mult = unit === "s" ? 1000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
+    return n * mult;
+}
+// A UTC day key (YYYY-MM-DD) for resetting per-day counters.
+export function dayKey(d = new Date()) {
+    return d.toISOString().slice(0, 10);
+}
+// Truthy reading of an opt-in env flag (1/true/yes/on, case-insensitive).
+export function envFlag(value) {
+    return ["1", "true", "yes", "on"].includes((value ?? "").trim().toLowerCase());
+}
+// Deep-scan a parsed frontmatter object for anything that looks like a secret.
+// The skill file is meant to be committable and shareable; a real key must
+// NEVER live in it (keys are supplied at runtime via env / encrypted store).
+// Returns a list of human-readable findings (empty = clean).
+const SECRET_KEY_RE = /(^|[_.-])(api[_-]?key|secret|token|password|passwd|bearer|authorization|private[_-]?key)($|[_.-])/i;
+const SECRET_VALUE_RE = /(crk_live_[a-z0-9_]+|sk-[a-z0-9-]{16,}|sk_live_[a-z0-9]{16,}|ghp_[a-z0-9]{20,}|bearer\s+[a-z0-9._-]{12,}|AIza[a-z0-9_-]{20,})/i;
+export function scanForSecrets(value, pathPrefix = "", findings = []) {
+    if (value == null)
+        return findings;
+    if (typeof value === "string") {
+        if (SECRET_VALUE_RE.test(value)) {
+            findings.push(`value at "${pathPrefix || "(root)"}" looks like a secret/credential`);
+        }
+        return findings;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((v, i) => scanForSecrets(v, `${pathPrefix}[${i}]`, findings));
+        return findings;
+    }
+    if (typeof value === "object") {
+        for (const [k, v] of Object.entries(value)) {
+            const here = pathPrefix ? `${pathPrefix}.${k}` : k;
+            if (SECRET_KEY_RE.test(k)) {
+                findings.push(`field "${here}" must not appear in a skill file (secret-like key)`);
+            }
+            scanForSecrets(v, here, findings);
+        }
+    }
+    return findings;
+}
+// Short random id (for runId/decisionId/idempotencyKey suffixes).
+export function shortId() {
+    // randomUUID is available in Node 18+ (globalThis.crypto).
+    return crypto.randomUUID().slice(0, 8);
+}
+// ── Resolver helpers (cross-platform-deterministic) ──────────────────────────
+// Normalize file content for hashing: CRLF/CR -> LF, strip trailing whitespace,
+// so a Windows checkout and a Linux checkout of the same file hash identically.
+export function normalizeContent(text) {
+    return text
+        .replace(/^/, "") // strip UTF-8 BOM (Windows editors add it)
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n")
+        .replace(/\s+$/, "");
+}
+// SHA-256 of normalized content — the manifest lock's per-file contentHash.
+export function sha256(text) {
+    return ("sha256:" + createHash("sha256").update(normalizeContent(text), "utf8").digest("hex"));
+}
+// Canonical POSIX path (forward slashes) so the lock is byte-identical on
+// Windows and Linux.
+export function toPosix(p) {
+    return p.replace(/\\/g, "/");
+}
+// True iff `child` resolves to a location strictly inside `parent`
+// (path-traversal guard). A `$ref` that escapes the agent folder is rejected.
+export function isPathInside(parent, child) {
+    const rel = relativePath(resolvePath(parent), resolvePath(child));
+    return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+// Keep only the most-recent slice of a (possibly large) memory file so a growing
+// journal never blows the model context / the user's token budget.
+export function boundTail(text, maxLines, maxBytes) {
+    let lines = text.split("\n");
+    if (lines.length > maxLines)
+        lines = lines.slice(-maxLines);
+    let out = lines.join("\n");
+    if (Buffer.byteLength(out, "utf8") > maxBytes) {
+        out = Buffer.from(out, "utf8").subarray(-maxBytes).toString("utf8");
+    }
+    return out;
+}
+// Deterministic JSON: recursively sort object keys so two runs over the same
+// inputs produce a byte-identical manifest.lock.json.
+export function stableStringify(value) {
+    return JSON.stringify(sortDeep(value), null, 2);
+}
+export function sortDeep(value) {
+    if (Array.isArray(value))
+        return value.map(sortDeep);
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const k of Object.keys(value).sort()) {
+            out[k] = sortDeep(value[k]);
+        }
+        return out;
+    }
+    return value;
+}

package/dist/agent/version.d.ts

@@ -0,0 +1,11 @@
+export declare const RUNNER_VERSION = "0.1.0";
+export declare const RESOLVER_VERSION = "1";
+export declare const MANIFEST_SCHEMA = "coinrithm.manifest.v1";
+export declare const COINRITHM_API: {
+    readonly kind: "coinrithm-agent-api";
+    readonly baseUrl: "https://api.coinrithm.com";
+    readonly mcpUrl: "https://mcp.coinrithm.com/mcp";
+    readonly openapiVersion: "1.4.0";
+    readonly mcpPackage: "@coinrithm/mcp-trading";
+    readonly mcpVersion: "0.3.0";
+};

package/dist/agent/version.js

@@ -0,0 +1,16 @@
+// Versions stamped into manifest.lock.json so a resolved agent is reproducible
+// only against the exact compile that produced it.
+export const RUNNER_VERSION = "0.1.0";
+export const RESOLVER_VERSION = "1";
+export const MANIFEST_SCHEMA = "coinrithm.manifest.v1";
+// The CoinRithm execution surface a generated agent talks to. Written into
+// functionality/coinrithm.yaml as a version PIN; the CLI warns when an agent's
+// pin lags this, but never blocks self-host use.
+export const COINRITHM_API = {
+    kind: "coinrithm-agent-api",
+    baseUrl: "https://api.coinrithm.com",
+    mcpUrl: "https://mcp.coinrithm.com/mcp",
+    openapiVersion: "1.4.0",
+    mcpPackage: "@coinrithm/mcp-trading",
+    mcpVersion: "0.3.0",
+};

package/dist/client.d.ts

@@ -0,0 +1,162 @@
+export declare const DEFAULT_BASE_URL = "https://api.coinrithm.com";
+export declare function log(...args: unknown[]): void;
+export interface ClientConfig {
+    apiKey?: string;
+    baseUrl: string;
+}
+export interface AgentTrace {
+    runId?: string;
+    decisionId?: string;
+    strategyLabel?: string;
+    confidence?: number;
+    rationaleSummary?: string;
+}
+export declare function loadConfig(): ClientConfig;
+export declare function loadHttpConfig(): ClientConfig;
+export declare function bearerFromHeader(value: string | string[] | undefined): string | undefined;
+export interface ApiResult {
+    ok: boolean;
+    status: number;
+    ledgerEventId?: string | null;
+    ledgerStatus?: string | null;
+    data: unknown;
+}
+type TraceableBody<T extends Record<string, unknown>> = T & {
+    agentTrace?: AgentTrace;
+};
+export declare class CoinRithmClient {
+    private readonly defaultApiKey?;
+    private readonly baseUrl;
+    constructor(config: ClientConfig);
+    private request;
+    whoami(apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getPortfolio(query?: {
+        fiat?: string;
+        locale?: string;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getWallet(query?: {
+        coinId?: string;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    resolveSymbol(query: {
+        q: string;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getEquityCurve(query?: {
+        days?: number;
+        granularity?: "daily" | "realized";
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getMyTrades(query?: {
+        venue?: string;
+        limit?: number;
+        updatedSince?: string;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getMarketContext(coinId: string, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getCandles(coinId: string, query?: {
+        range?: "1H" | "1D" | "1W" | "1M" | "3M";
+        fiat?: string;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    discoverPmMarkets(query?: {
+        q?: string;
+        source?: "all" | "kalshi" | "polymarket";
+        limit?: number;
+        offset?: number;
+        sort?: string;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getPerformance(apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getLedger(query?: {
+        venue?: string;
+        eventType?: string;
+        runId?: string;
+        decisionId?: string;
+        status?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+        offset?: number;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    exportLedger(query?: {
+        venue?: string;
+        eventType?: string;
+        runId?: string;
+        decisionId?: string;
+        status?: string;
+        from?: string;
+        to?: string;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getArenaLeaderboard(query?: {
+        page?: number;
+        pageSize?: number;
+        window?: "7d" | "30d" | "all";
+    }, apiKey?: string): Promise<ApiResult>;
+    getArenaAgent(handle: string, apiKey?: string): Promise<ApiResult>;
+    listOpenOrders(query?: {
+        coinId?: string;
+        limit?: number;
+        updatedSince?: string;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getFuturesPositions(query?: {
+        updatedSince?: string;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getPmPositions(query?: {
+        updatedSince?: string;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    futuresQuote(body: {
+        coinId: string;
+        side: string;
+        leverage: number;
+        marginMusd: number;
+    } & {
+        agentTrace?: AgentTrace;
+    }, apiKey?: string): Promise<ApiResult>;
+    pmQuote(body: {
+        source: string;
+        slug: string;
+        outcomeExternalMarketId: string;
+        stakeMusd: number;
+    } & {
+        agentTrace?: AgentTrace;
+    }, apiKey?: string): Promise<ApiResult>;
+    spotQuote(body: {
+        coinId: string;
+        side: string;
+        quantity: number;
+    } & {
+        agentTrace?: AgentTrace;
+    }, apiKey?: string): Promise<ApiResult>;
+    placeSpotOrder(body: TraceableBody<{
+        coinId: string;
+        side: string;
+        orderType: string;
+        quantity: number;
+        limitPrice?: number;
+        stopPrice?: number;
+        idempotencyKey: string;
+    }>, apiKey?: string): Promise<ApiResult>;
+    cancelSpotOrder(orderId: number, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    openFuturesPosition(body: TraceableBody<{
+        coinId: string;
+        side: string;
+        leverage: number;
+        marginMusd: number;
+        idempotencyKey: string;
+        stopLossPrice?: number | null;
+        takeProfitPrice?: number | null;
+    }>, apiKey?: string): Promise<ApiResult>;
+    setFuturesSlTp(body: TraceableBody<{
+        positionId: number;
+        stopLossPrice?: number | null;
+        takeProfitPrice?: number | null;
+    }>, apiKey?: string): Promise<ApiResult>;
+    closeFuturesPosition(body: TraceableBody<{
+        positionId: number;
+        fraction?: number;
+        idempotencyKey: string;
+    }>, apiKey?: string): Promise<ApiResult>;
+    openPmPosition(body: TraceableBody<{
+        source: string;
+        slug: string;
+        outcomeExternalMarketId: string;
+        stakeMusd: number;
+        idempotencyKey: string;
+    }>, apiKey?: string): Promise<ApiResult>;
+}
+export {};