@coinrithm/mcp-trading 0.7.14 → 0.7.15

package/dist/agent/providerCapabilities.js

@@ -54,18 +54,48 @@ export function chatShapeFor(provider, model, baseUrl) {
         minProbeCompletionTokens: 1024,
     };
 }
+// Transport-only restriction: drop the excluded variants from the action oneOf
+// a route decodes against. parseDecision keeps validating the FULL contract, so
+// a route that does not enforce a schema can still propose the action and the
+// validator rejects it. Never returns an empty oneOf.
+export function restrictDecisionSchema(schema, exclude) {
+    if (!exclude?.length)
+        return schema;
+    const properties = schema.properties;
+    const actions = properties?.actions;
+    const variants = actions?.items?.oneOf;
+    if (!properties || !actions || !Array.isArray(variants))
+        return schema;
+    const kept = variants.filter((variant) => {
+        const type = variant
+            .properties?.type?.const;
+        return !exclude.includes(type);
+    });
+    if (kept.length === variants.length || kept.length === 0)
+        return schema;
+    return {
+        ...schema,
+        properties: {
+            ...properties,
+            actions: { ...actions, items: { ...actions.items, oneOf: kept } },
+        },
+    };
+}
 /** Build the chat-completions body for a route from its capability shape. */
 export function buildChatBody(shape, args) {
     const system = shape.systemHint
         ? `${shape.systemHint}\n\n${args.system}`
         : args.system;
+    const jsonSchema = shape.jsonSchema
+        ? restrictDecisionSchema(shape.jsonSchema, args.excludeActionTypes)
+        : undefined;
     return {
         model: args.model,
         ...(shape.allowsTemperature
             ? { temperature: args.temperature ?? 0.2 }
             : {}),
         [shape.tokenParam]: args.maxTokens,
-        ...(shape.jsonSchema && shape.jsonSchemaTransport === "tool_call"
+        ...(jsonSchema && shape.jsonSchemaTransport === "tool_call"
             ? {
                 tools: [
                     {
@@ -73,7 +103,7 @@ export function buildChatBody(shape, args) {
                         function: {
                             name: DECISION_TOOL_NAME,
                             description: "Submit the complete CoinRithm paper-trading decision for this cycle.",
-                            parameters: shape.jsonSchema,
+                            parameters: jsonSchema,
                         },
                     },
                 ],
@@ -85,12 +115,12 @@ export function buildChatBody(shape, args) {
             : {}),
         ...(shape.jsonResponseFormat && shape.jsonSchemaTransport !== "tool_call"
             ? {
-                response_format: shape.jsonSchema
+                response_format: jsonSchema
                     ? {
                         type: "json_schema",
                         json_schema: {
                             name: "coinrithm_trading_decision",
-                            schema: shape.jsonSchema,
+                            schema: jsonSchema,
                         },
                     }
                     : { type: "json_object" },

package/dist/agent/providers.d.ts

@@ -1,9 +1,11 @@
 import { AgentSpec, ProviderName } from "./types.js";
+import { type DecisionActionExclusion } from "./providerCapabilities.js";
 export interface DecideInput {
     system: string;
     user: string;
     maxTokens?: number;
     timeoutMs?: number;
+    excludeActionTypes?: readonly DecisionActionExclusion[];
 }
 export interface DecideRouteAttempt {
     provider: string;
@@ -26,6 +28,7 @@ export interface DecideRouteMeta {
 export type DecideResult = {
     ok: true;
     text: string;
+    responseSource?: "tool_call" | "content_fallback" | "content";
     usage?: {
         promptTokens: number;
         completionTokens: number;

package/dist/agent/providers.js

@@ -193,7 +193,7 @@ class AnthropicProvider {
                     }
                     : undefined;
                 return text
-                    ? { ok: true, text, usage }
+                    ? { ok: true, text, usage, responseSource: "content" }
                     : { ok: false, error: "anthropic returned empty content" };
             });
         }
@@ -246,6 +246,7 @@ class OpenAiCompatProvider {
                         system: input.system,
                         user: input.user,
                         maxTokens: input.maxTokens ?? 1024,
+                        excludeActionTypes: input.excludeActionTypes,
                     })),
                 });
                 if (!res.ok) {
@@ -273,7 +274,16 @@ class OpenAiCompatProvider {
                     }
                     : undefined;
                 return text
-                    ? { ok: true, text, usage }
+                    ? {
+                        ok: true,
+                        text,
+                        usage,
+                        responseSource: decisionArguments != null
+                            ? "tool_call"
+                            : shape.jsonSchemaTransport === "tool_call"
+                                ? "content_fallback"
+                                : "content",
+                    }
                     : { ok: false, error: "provider returned empty content" };
             });
         }

package/dist/agent/runner.js

@@ -9,10 +9,11 @@ import { usesCapitalSizing, prepareCapitalAction, validateCapitalAction, capital
 import { decideMechanical } from "./mechanical.js";
 import { evaluateGate, noteLlmCall, estimateCostUsd } from "./gate.js";
 import { baseSymbol, scanSetups } from "./setups.js";
+import { futuresEntryPreflight } from "./futuresEligibility.js";
 import { reconcileObservation } from "./reconcileObservation.js";
 import { createOpportunityReporter } from "./opportunityReporter.js";
-import { observe } from "./observe.js";
-import { buildDailyRiskBudget, buildSystemPrompt, buildUserPrompt, } from "./prompt.js";
+import { enrichWhaleContext, observe } from "./observe.js";
+import { buildDailyRiskBudget, buildFuturesCapacity, buildSystemPrompt, buildUserPrompt, } from "./prompt.js";
 import { parseDecision } from "./decision.js";
 import { validateAction, isRiskIncreasingAction, } from "./decisionValidator.js";
 import { resolvePmRef } from "./resolvePm.js";
@@ -435,6 +436,19 @@ async function runCycleCore(deps, capture) {
     const decisionId = makeDecisionId(state.cyclesRun);
     const captureBase = { runId, decisionId, spec, mergedProse, state };
     capture({ ...captureBase, phase: "before_observation" });
+    // These exits happen before both provider invocation and action execution.
+    // Record that known absence explicitly; missing metering means unknown to
+    // audit consumers. Do not default later failures to zero: a call/write may
+    // already have occurred by then.
+    const preDecisionMeter = {
+        llmCallMade: false,
+        decisionType: "skip",
+        tokensIn: 0,
+        tokensOut: 0,
+        estimatedCostUsd: 0,
+        writeAttempted: 0,
+        writeAccepted: 0,
+    };
     // Kill-switch pre-check: a disabled agent never observes, decides, or acts.
     const tripped = checkKillSwitch(spec, state);
     if (tripped) {
@@ -448,6 +462,7 @@ async function runCycleCore(deps, capture) {
             disabled: true,
             disabledReason: tripped,
             live,
+            ...preDecisionMeter,
         };
     }
     // Establish durable run identity before the first possible write. A process
@@ -511,6 +526,7 @@ async function runCycleCore(deps, capture) {
             disabled: true,
             disabledReason: state.disabledReason,
             live,
+            ...preDecisionMeter,
             ...observationReceipt,
         };
     }
@@ -535,6 +551,7 @@ async function runCycleCore(deps, capture) {
                     disabled: true,
                     disabledReason: state.disabledReason,
                     live,
+                    ...preDecisionMeter,
                     ...observationReceipt,
                 };
             }
@@ -546,6 +563,7 @@ async function runCycleCore(deps, capture) {
             skipReason: obs.skip,
             planned: [],
             live,
+            ...preDecisionMeter,
             ...observationReceipt,
         };
     }
@@ -624,15 +642,15 @@ async function runCycleCore(deps, capture) {
     // so it touches NO kill-switch counter; it just records the cheap cycle.
     const policy = spec.triggerPolicy ?? DEFAULT_TRIGGER_POLICY;
     const gate = evaluateGate(observation, state, policy, nowMs);
-    capture({
-        ...captureBase,
-        phase: "decision_input",
-        observation,
-        observationFingerprint: observationReceipt.observationHash,
-        preThesisObservationFingerprint,
-    });
     const providerName = spec.model?.provider ?? "nvidia";
     if (!gate.fire) {
+        capture({
+            ...captureBase,
+            phase: "decision_input",
+            observation,
+            observationFingerprint: observationReceipt.observationHash,
+            preThesisObservationFingerprint,
+        });
         saveState(stateFile, state);
         log(`gate: skip (${gate.reason})`);
         return {
@@ -651,6 +669,20 @@ async function runCycleCore(deps, capture) {
             ...observationReceipt,
         };
     }
+    if (providerName !== "mechanical" &&
+        spec.capabilities.includes("whale_context") &&
+        spec.venues.includes("pm")) {
+        observation.whaleContext = await enrichWhaleContext(client, observation);
+        observationReceipt = buildObservationReceipt(observation);
+        Object.assign(baseTrace, observationReceipt);
+    }
+    capture({
+        ...captureBase,
+        phase: "decision_input",
+        observation,
+        observationFingerprint: observationReceipt.observationHash,
+        preThesisObservationFingerprint,
+    });
     // DECIDE. Two paths share the same downstream validate+act loop:
     //   • mechanical benchmark agents (provider "mechanical") compute the decision
     //     deterministically from the observation — no prompt, no model call, no
@@ -678,19 +710,43 @@ async function runCycleCore(deps, capture) {
         };
     }
     else {
+        const futuresCapacity = spec.venues.includes("futures")
+            ? buildFuturesCapacity(spec, observation)
+            : undefined;
+        // One exclusion drives both the textual action menu and transport schema.
+        // It is a proposal hint only; parsing and validation stay unchanged.
+        const capacitySpent = futuresCapacity !== undefined &&
+            (futuresCapacity.slotsLeft === 0 ||
+                futuresCapacity.marginHeadroomMusd <= 0);
+        const actionAvailability = capacitySpent
+            ? { excludeActionTypes: ["futures_open"] }
+            : {};
         const system = buildSystemPrompt(spec, mergedProse, {
             includeForecast: forecastEnabled,
+            ...actionAvailability,
         });
         const user = buildUserPrompt(observation, state.journal, {
             venues: spec.venues,
             dailyRiskBudget: buildDailyRiskBudget(spec, state),
             ...(usesCapitalSizing(spec) ? { capitalSizing: spec.capitalSizing } : {}),
+            ...(futuresCapacity ? { futuresCapacity } : {}),
+            ...actionAvailability,
         });
         const tokensInEst = Math.round((system.length + user.length) / 4);
         // Prompt-size + trigger visibility in the live terminal.
         log(`prompt ~${tokensInEst} tok ` +
             `(pm ${observation.pmMarkets.length}, trades ${observation.newClosedTrades.length}, watch ${observation.watch.length}, setups ${observation.setups.length}, triggers ${gate.codes.join("|") || "none"})`);
-        const res = await provider.decide({ system, user });
+        // With either futures cap spent, a schema-enforcing route is not offered
+        // futures_open at all. Other routes can still propose it; the validator
+        // rejects it there exactly as before.
+        if (capacitySpent) {
+            log(`futures capacity spent (slotsLeft ${futuresCapacity.slotsLeft}, marginHeadroomMusd ${futuresCapacity.marginHeadroomMusd}): futures_open withheld from schema-enforcing routes`);
+        }
+        const res = await provider.decide({
+            system,
+            user,
+            ...actionAvailability,
+        });
         const route = res.route;
         const actualCallMade = route
             ? route.attempts.some((attempt) => attempt.outcome !== "deferred")
@@ -841,6 +897,22 @@ async function runCycleCore(deps, capture) {
         state.consecutivePermanentModelErrors = 0;
         delete state.permanentModelErrorRoute;
         const parsed = parseDecision(res.text);
+        if (capacitySpent) {
+            // Persist only route provenance and a parsed action-presence bit in the
+            // existing cycle log. Unknown adapters and malformed decisions must not
+            // be miscounted as tool compliance; raw output stays unretained.
+            const responseSource = res.responseSource === "tool_call" ||
+                res.responseSource === "content_fallback" ||
+                res.responseSource === "content"
+                ? res.responseSource
+                : "unknown";
+            log(`capacity-response ${JSON.stringify({
+                responseSource,
+                withheldActionProposed: parsed.ok
+                    ? parsed.decision.actions.some((action) => action.type === "futures_open")
+                    : null,
+            })}`);
+        }
         if (!parsed.ok) {
             state.consecutiveModelFailures += 1;
             saveState(stateFile, state);
@@ -966,7 +1038,7 @@ async function runCycleCore(deps, capture) {
                 log(`reject pm_open: duplicate_intent (hold PM ${pm.slug})`);
                 continue;
             }
-            // Independent forecast submission (HOUSE_AGENT_FORECAST_ENABLED, default ON).
+            // Market-aware forecast submission (HOUSE_AGENT_FORECAST_ENABLED, default ON).
             // Attach the model's OWN probability the backed side wins — clamped to [1,99],
             // OMITTED when absent/unparseable (a bad forecast never blocks the trade), and
             // NEVER defaulted to the market price. Flag OFF strips any forecast so the open
@@ -1058,6 +1130,23 @@ async function runCycleCore(deps, capture) {
                 }
             }
         }
+        // Supported-reference preflight (backend-v2 #106, J-74): skip a NEW futures
+        // open on a coin the observation EXPLICITLY reports has no supported (or only
+        // a stale) perpetual reference, before spending a quote the server gate would
+        // refuse. Unknown eligibility, adds/management on a held coin, spot and PM
+        // pass; the server gate stays authoritative at quote/open time.
+        const preflight = futuresEntryPreflight(action, observation);
+        if (preflight) {
+            planned.push({
+                action,
+                accepted: false,
+                code: preflight.code,
+                ...(capitalSizing ? { capitalSizing } : {}),
+                reason: preflight.reason,
+            });
+            log(`reject ${action.type}: ${preflight.code}`);
+            continue;
+        }
         const quote = await fetchQuote(client, action, observation, baseTrace, {
             pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct,
         });

package/dist/agent/templates.js

@@ -50,37 +50,37 @@ const PRESETS = {
         modelFail: 5,
     },
 };
-const THESIS_BODY = `# Momentum Futures — strategy
-
-You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
-Everything here is simulated; it is not financial advice and never touches real
-money. Edit this prose freely (any language) — it is your agent's borders.
-
-## Each cycle
-
-1. Ground yourself: read your portfolio and open positions first. Never assume
-   balances or what is already open.
-2. Scan the watchlist. A candidate is a coin whose short and medium momentum
-   agree (both up, or both down) and is not already an open position.
-3. Pick the strongest candidate and commit when the read is clear — even a
-   moderate-confidence one — sized small with a stop. Skip only when the signals
-   contradict or the data is stale; a quiet tape where your edge is still real
-   is an act, not a skip.
-4. Quote before you open. Read the liquidation price and confirm it is sane. If
-   the quote is not eligible, relay the reason and stop.
-5. Open small and protected: enter in the trend direction and set a stop-loss at
-   open. Place the take-profit a touch wider than the stop.
-6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
-   fired while you were not looking, and react to what actually happened.
-
-The hard caps (leverage, margin, watchlist) live in the config blocks above and
+const THESIS_BODY = `# Momentum Futures — strategy
+
+You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
+Everything here is simulated; it is not financial advice and never touches real
+money. Edit this prose freely (any language) — it is your agent's borders.
+
+## Each cycle
+
+1. Ground yourself: read your portfolio and open positions first. Never assume
+   balances or what is already open.
+2. Scan the watchlist. A candidate is a coin whose short and medium momentum
+   agree (both up, or both down) and is not already an open position.
+3. Pick the strongest candidate and commit when the read is clear — even a
+   moderate-confidence one — sized small with a stop. Skip only when the signals
+   contradict or the data is stale; a quiet tape where your edge is still real
+   is an act, not a skip.
+4. Quote before you open. Read the liquidation price and confirm it is sane. If
+   the quote is not eligible, relay the reason and stop.
+5. Open small and protected: enter in the trend direction and set a stop-loss at
+   open. Place the take-profit a touch wider than the stop.
+6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
+   fired while you were not looking, and react to what actually happened.
+
+The hard caps (leverage, margin, watchlist) live in the config blocks above and
 are enforced by the runner — change them there, not in this prose.`;
-const PERSONA_STUB = `# Persona
-
-Decisive and in character. Acts on a clear read — even a moderate-confidence one
-— sized small and protected with a stop, and skips only when the read is
-contradictory or the data is stale. States its reasoning plainly in its own
-voice, and never frames paper results as real-money advice.
+const PERSONA_STUB = `# Persona
+
+Decisive and in character. Acts on a clear read — even a moderate-confidence one
+— sized small and protected with a stop, and skips only when the read is
+contradictory or the data is stale. States its reasoning plainly in its own
+voice, and never frames paper results as real-money advice.
 `;
 export function buildAgentObject(name, preset) {
     const p = PRESETS[preset];

package/dist/agent/types.d.ts

@@ -1,3 +1,4 @@
+import type { FuturesEntryEligibility } from "./futuresEligibility.js";
 import { IndicatorSet } from "./indicators.js";
 import type { DecisionInputRecord } from "./decisionReceipt.js";
 export declare const SPEC_VERSION = "coinrithm.agent.v1";
@@ -97,7 +98,7 @@ export interface ObjectiveConfig {
     secondary: string[];
     horizon?: string;
 }
-export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators", "news", "universe_scan"];
+export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators", "news", "universe_scan", "whale_context"];
 export type Capability = (typeof ALLOWED_CAPABILITIES)[number];
 export interface AgentSpec {
     name: string;
@@ -158,12 +159,16 @@ export interface WatchEntry {
     change24h?: number;
     change7d?: number;
     sentimentBullishPct?: number;
+    sentimentTotalVotes?: number;
+    sentimentDayUtc?: string;
+    sentimentUpdatedAt?: string;
     freshness?: Freshness;
     indicators?: IndicatorSet;
     indicatorContext?: IndicatorContext;
     discovered?: boolean;
     slug?: string;
     fundamentals?: CoinFundamentals;
+    futuresEntryEligibility?: FuturesEntryEligibility;
 }
 export interface CoinFundamentals {
     categories?: string[];
@@ -247,6 +252,42 @@ export interface PmMarket {
     liquidityUsd?: number;
     quality?: PmQuality;
     decisionSupport?: PmDecisionSupport;
+    consensus?: PmConsensus | null;
+    rules?: PmSettlementRule | null;
+    outcomeRule?: PmOutcomeRule;
+}
+export interface PmCalibration {
+    settled: number;
+    brierAgent: number | null;
+    brierMarket: number | null;
+    meanForecastPct: number | null;
+    winRatePct: number | null;
+    bands: Array<{
+        fromPct: number;
+        toPct: number;
+        n: number;
+        meanForecastPct: number;
+        winRatePct: number;
+    }>;
+}
+export interface PmSettlementRule {
+    published: boolean;
+    text?: string;
+    sources?: string[];
+    scope?: "per_outcome";
+}
+export type PmOutcomeRule = {
+    primary: string;
+    secondary?: string;
+} | {
+    unknown: "source_rules_unavailable" | "market_not_found" | "rule_missing" | "conflicting_duplicates" | "unreadable";
+};
+export interface PmConsensus {
+    prob: number;
+    venues: number;
+    spreadPts: number;
+    kind: "binary" | "leader";
+    outcome: string | null;
 }
 export interface PmQuality {
     decisionEligible?: boolean;
@@ -282,6 +323,78 @@ export interface NewsItem {
     publishedAt?: string;
     coins?: string[];
 }
+export type WhaleContextStatus = "available" | "partial" | "unavailable";
+export type WhaleContextFailure = "timeout" | "network_error" | "http_error" | "invalid_payload";
+export interface WhaleTradeContext {
+    source: string;
+    eventSlug: string;
+    eventTitle?: string;
+    marketQuestion?: string;
+    side: string;
+    outcome?: string;
+    usdValue?: number;
+    price?: number;
+    sourceMarketRef?: string;
+    valueBasis?: string;
+    evidenceType?: string;
+    evidenceRef?: string;
+    nativeValue?: number;
+    nativeCurrency?: string;
+    availability?: "live" | "delayed" | "unavailable";
+    tradedAt?: string;
+    observedAt?: string;
+    latencySeconds?: number;
+    walletAddress?: string;
+}
+export interface WhaleWalletFillContext {
+    eventSlug?: string;
+    eventTitle?: string;
+    marketQuestion?: string;
+    side?: string;
+    outcome?: string;
+    usdValue?: number;
+    price?: number;
+    evidenceType?: string;
+    tradedAt?: string;
+    sourceMarketRef?: string;
+}
+export interface WhaleWalletContext {
+    source: string;
+    address: string;
+    asOf?: string;
+    summary30d?: {
+        basis?: string;
+        windowStart?: string;
+        tradeCount?: number;
+        notionalUsd?: number;
+        buyNotionalUsd?: number;
+        sellNotionalUsd?: number;
+    };
+    rollup?: {
+        available?: boolean;
+        coveredDays?: number;
+        from?: string;
+        to?: string;
+        computedAt?: string;
+    };
+    daily: Array<{
+        day?: string;
+        tradeCount?: number;
+        buyCount?: number;
+        sellCount?: number;
+        notionalUsd?: number;
+    }>;
+    recentFills: WhaleWalletFillContext[];
+}
+export interface WhaleContext {
+    status: WhaleContextStatus;
+    fetchedAt: string;
+    coverage: "relevant_events" | "no_relevant_events";
+    trades: WhaleTradeContext[];
+    wallets: WhaleWalletContext[];
+    omitted: number;
+    reason?: WhaleContextFailure;
+}
 export interface Observation {
     asOf: string;
     scopes: string[];
@@ -293,16 +406,19 @@ export interface Observation {
     pmPositions: PmPosition[];
     pmResolutions: PmResolution[];
     pmMarkets: PmMarket[];
+    pmCalibration?: PmCalibration;
     watch: WatchEntry[];
     setups: SetupSignal[];
     marketMood?: {
         fearGreed: number;
         label: string;
+        fetchedAt?: string;
     };
     syncCursor: string | null;
     newClosedTrades: Array<Record<string, unknown>>;
     polledBeforeWrite: boolean;
     news?: NewsItem[];
+    whaleContext?: WhaleContext;
     universeMovers?: Array<{
         symbol: string;
         name?: string;

package/dist/agent/types.js

@@ -50,6 +50,9 @@ export const OBJECTIVE_PRIMARIES = [
 // 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.
+// `whale_context` reads bounded public prediction-market whale context only
+// after the deterministic gate fires, and only when PM is in the venue scope.
+// It never widens the candidate set or acts as a trading signal by itself.
 // `universe_scan` (2026-08-18, direct user request): each cycle the runner
 // pulls the top 24h movers across CoinRithm's tracked coin universe, resolves
 // the top few into FULL watch entries (price, sentiment, indicators when that
@@ -64,6 +67,7 @@ export const ALLOWED_CAPABILITIES = [
     "indicators",
     "news",
     "universe_scan",
+    "whale_context",
 ];
 export const ok = () => ({ valid: true });
 export const fail = (code, reason) => ({

package/dist/client.d.ts

@@ -39,6 +39,7 @@ export type ProvenanceReport = {
         sourceCapturedAt?: string;
     };
 };
+export declare const API_KEY_MINT_URL = "https://www.coinrithm.com/en/settings/api-keys";
 export declare class CoinRithmClient {
     private readonly defaultApiKey?;
     private readonly baseUrl;
@@ -113,6 +114,12 @@ export declare class CoinRithmClient {
         range?: "1H" | "1D" | "1W" | "1M" | "3M";
         fiat?: string;
     }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getNews(query: {
+        coins: string;
+        limit?: number;
+        hours?: number;
+        minImportance?: number;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
     discoverPmMarkets(query?: {
         q?: string;
         source?: "all" | "kalshi" | "polymarket";
@@ -145,8 +152,8 @@ export declare class CoinRithmClient {
         page?: number;
         pageSize?: number;
         window?: "7d" | "30d" | "all";
-    }, apiKey?: string): Promise<ApiResult>;
-    getArenaAgent(handle: string, apiKey?: string): Promise<ApiResult>;
+    }): Promise<ApiResult>;
+    getArenaAgent(handle: string): Promise<ApiResult>;
     listOpenOrders(query?: {
         coinId?: string;
         limit?: number;