pmxt-core 2.50.16 → 2.51.0

package/dist/exchanges/hunch/utils.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUNCH_PROMOTED_MARKET_KEYS = exports.BASE_USDC_ADDRESS = exports.BASE_CHAIN_ID = exports.DEFAULT_BASE_URL = void 0;
+exports.mapHunchStatus = mapHunchStatus;
+exports.mapStatusToHunch = mapStatusToHunch;
+exports.buildOutcomeId = buildOutcomeId;
+exports.parseHunchSide = parseHunchSide;
+exports.mapHunchMarketToUnified = mapHunchMarketToUnified;
+const market_utils_1 = require("../../utils/market-utils");
+const metadata_1 = require("../../utils/metadata");
+/**
+ * Canonical Hunch agent-platform base URL. Reads are keyless (CORS `*`);
+ * the trade route settles real Base USDC via x402 / EIP-3009.
+ */
+exports.DEFAULT_BASE_URL = 'https://www.playhunch.xyz';
+/** Base mainnet — the ONLY settlement chain on Hunch's agent rail. */
+exports.BASE_CHAIN_ID = 8453;
+/** USDC on Base (the EIP-3009 `transferWithAuthorization` asset). */
+exports.BASE_USDC_ADDRESS = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913';
+/**
+ * Raw Hunch fields already promoted to first-class Unified columns — excluded
+ * from `sourceMetadata` so we capture only what the unified shape would drop
+ * (e.g. headline, deadlineLabel, feeRecipientLabel, defaultTicketUsd, links).
+ */
+exports.HUNCH_PROMOTED_MARKET_KEYS = [
+    'id',
+    'slug',
+    'question',
+    'summary',
+    'category',
+    'tokenSymbol',
+    'chainId',
+    'deadlineAt',
+    'status',
+    'feeBps',
+    'virtualLiquidityUsd',
+    'volumeUsd',
+    'targetMarketCapUsd',
+    'outcomes',
+];
+/**
+ * Map a Hunch status (open / closed / resolved) to the pmxt unified lifecycle
+ * vocabulary (active / inactive / closed). Unknown → 'active' (Hunch only lists
+ * `open` markets when `status=open`, so this is defensive).
+ */
+function mapHunchStatus(status) {
+    switch (status) {
+        case 'open':
+            return 'active';
+        case 'closed':
+            return 'inactive';
+        case 'resolved':
+        case 'voided':
+            return 'closed';
+        default:
+            return 'active';
+    }
+}
+/**
+ * Translate the pmxt unified `status` filter into the Hunch `status` query
+ * value. Hunch only accepts `open` | `all`; 'inactive'/'closed' have no live
+ * listing, so they fold to `all` (the caller filters client-side afterwards).
+ */
+function mapStatusToHunch(status) {
+    if (!status)
+        return undefined;
+    switch (status) {
+        case 'active':
+            return 'open';
+        case 'inactive':
+        case 'closed':
+        case 'all':
+            return 'all';
+        default:
+            return undefined;
+    }
+}
+/**
+ * Compose an outcome id that round-trips back to a Hunch trade `side`.
+ *
+ * Encoding: `${marketId}:${side}` where `side` is `yes` | `no` for binary
+ * markets, or the parimutuel bucket `key` (e.g. `le-330m`, `up`, `down`,
+ * a date-window key) for N-way markets. `parseHunchSide()` reverses it.
+ */
+function buildOutcomeId(marketId, side) {
+    return `${marketId}:${side}`;
+}
+/**
+ * Reverse {@link buildOutcomeId}: pull the Hunch `side` token back out of a
+ * unified `outcomeId`. The market id itself may contain a `:` is NOT a concern —
+ * Hunch ids are slug-shaped (`[a-z0-9-]`), so the FIRST colon never appears
+ * inside an id; we split on the LAST colon to be safe regardless.
+ */
+function parseHunchSide(outcomeId) {
+    const idx = outcomeId.lastIndexOf(':');
+    if (idx <= 0 || idx === outcomeId.length - 1) {
+        // No separator — treat the whole thing as the side with no market id.
+        return { marketId: '', side: outcomeId };
+    }
+    return {
+        marketId: outcomeId.slice(0, idx),
+        side: outcomeId.slice(idx + 1),
+    };
+}
+/**
+ * Shared market normalizer used by both the live fetch path and the (rare)
+ * direct-mapping helper. Pulls a Hunch market ref into a {@link UnifiedMarket}.
+ *
+ * - Binary markets (`outcomes == null`) get YES/NO outcomes priced from `odds`
+ *   when supplied (research/quote-derived), else flat 0 (the list endpoint
+ *   does not carry live odds — they ride on the quote/research single-market
+ *   reads, matching Myriad's "static on list, live on detail" model).
+ * - N-way markets expand `outcomes[]` into one {@link MarketOutcome} per rung,
+ *   carrying `impliedPct/100` as the price when a live ladder is supplied.
+ *
+ * `outcomeId` round-trips to a Hunch `side` (see {@link buildOutcomeId}).
+ */
+function mapHunchMarketToUnified(raw, odds, ladder) {
+    if (!raw || !raw.id)
+        return null;
+    const marketId = raw.id;
+    let outcomes;
+    if (Array.isArray(raw.outcomes) && raw.outcomes.length > 0) {
+        // N-way parimutuel ladder / date-window market.
+        const ladderByKey = new Map();
+        for (const lo of ladder?.outcomes ?? [])
+            ladderByKey.set(lo.key, lo);
+        outcomes = raw.outcomes.map((o) => {
+            const live = ladderByKey.get(o.key);
+            const price = live && typeof live.impliedPct === 'number' ? live.impliedPct / 100 : 0;
+            return {
+                outcomeId: buildOutcomeId(marketId, o.key),
+                marketId,
+                label: o.label,
+                price,
+                metadata: {
+                    key: o.key,
+                    shortLabel: o.shortLabel,
+                    lowerUsd: o.lowerUsd,
+                    upperUsd: o.upperUsd,
+                    startAt: o.startAt ?? null,
+                    endAt: o.endAt ?? null,
+                    backedUsd: live?.backedUsd ?? null,
+                    isCurrent: live?.isCurrent ?? null,
+                },
+            };
+        });
+    }
+    else {
+        // Binary YES/NO market.
+        const yesPrice = odds && typeof odds.yesPriceCents === 'number' ? odds.yesPriceCents / 100 : 0;
+        const noPrice = odds && typeof odds.noPriceCents === 'number'
+            ? odds.noPriceCents / 100
+            : yesPrice > 0
+                ? 1 - yesPrice
+                : 0;
+        outcomes = [
+            { outcomeId: buildOutcomeId(marketId, 'yes'), marketId, label: 'Yes', price: yesPrice },
+            { outcomeId: buildOutcomeId(marketId, 'no'), marketId, label: 'No', price: noPrice },
+        ];
+    }
+    const um = {
+        marketId,
+        title: raw.question || raw.shortTitle || '',
+        description: raw.summary || '',
+        slug: raw.slug,
+        outcomes,
+        resolutionDate: raw.deadlineAt ? new Date(raw.deadlineAt) : undefined,
+        // Hunch is parimutuel and reports no 24h volume split — surface 0.
+        volume24h: 0,
+        volume: typeof raw.volumeUsd === 'number' ? raw.volumeUsd : undefined,
+        liquidity: Number(raw.virtualLiquidityUsd || 0),
+        url: raw.links?.app || `${exports.DEFAULT_BASE_URL}/markets/${raw.slug || marketId}`,
+        category: raw.category,
+        tags: raw.tokenSymbol ? [raw.tokenSymbol] : [],
+        status: mapHunchStatus(raw.status),
+        sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw, exports.HUNCH_PROMOTED_MARKET_KEYS),
+    };
+    // Standardize yes/no/up/down convenience accessors for binary markets.
+    (0, market_utils_1.addBinaryOutcomes)(um);
+    return um;
+}

package/dist/exchanges/hunch/websocket.d.ts

@@ -0,0 +1,25 @@
+import { OrderBook, Trade } from '../../types';
+export type FetchOrderBookFn = (id: string) => Promise<OrderBook>;
+export type FetchTradesFn = (id: string, limit: number) => Promise<Trade[]>;
+export declare class HunchWebSocket {
+    private readonly fetchOrderBook;
+    private readonly fetchTrades;
+    private readonly pollInterval;
+    private orderBookTimers;
+    private tradeTimers;
+    private orderBookResolvers;
+    private orderBookRejecters;
+    private tradeResolvers;
+    private tradeRejecters;
+    private seenTradeIds;
+    private orderBookFailureCount;
+    private tradeFailureCount;
+    private closed;
+    constructor(fetchOrderBook: FetchOrderBookFn, fetchTrades: FetchTradesFn, pollInterval?: number);
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    watchTrades(outcomeId: string): Promise<Trade[]>;
+    close(): Promise<void>;
+    private startOrderBookPolling;
+    private startTradePolling;
+    private handleFailure;
+}

package/dist/exchanges/hunch/websocket.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HunchWebSocket = void 0;
+const logger_1 = require("../../utils/logger");
+/**
+ * Hunch exposes SSE at /api/agent/v1/events for resolution awareness, but no
+ * market-data WebSocket. watchOrderBook / watchTrades are emulated with a
+ * poll-based fallback (matching the CCXT Pro async pattern + Myriad's adapter).
+ */
+const DEFAULT_POLL_INTERVAL = 5000; // 5s
+const MAX_CONSECUTIVE_FAILURES = 5;
+class HunchWebSocket {
+    fetchOrderBook;
+    fetchTrades;
+    pollInterval;
+    orderBookTimers = new Map();
+    tradeTimers = new Map();
+    orderBookResolvers = new Map();
+    orderBookRejecters = new Map();
+    tradeResolvers = new Map();
+    tradeRejecters = new Map();
+    seenTradeIds = new Map();
+    orderBookFailureCount = new Map();
+    tradeFailureCount = new Map();
+    closed = false;
+    constructor(fetchOrderBook, fetchTrades, pollInterval) {
+        this.fetchOrderBook = fetchOrderBook;
+        this.fetchTrades = fetchTrades;
+        this.pollInterval = pollInterval || DEFAULT_POLL_INTERVAL;
+    }
+    async watchOrderBook(outcomeId) {
+        if (this.closed)
+            throw new Error('Hunch watch connection is closed');
+        return new Promise((resolve, reject) => {
+            if (!this.orderBookResolvers.has(outcomeId)) {
+                this.orderBookResolvers.set(outcomeId, []);
+                this.orderBookRejecters.set(outcomeId, []);
+            }
+            this.orderBookResolvers.get(outcomeId).push(resolve);
+            this.orderBookRejecters.get(outcomeId).push(reject);
+            if (!this.orderBookTimers.has(outcomeId))
+                this.startOrderBookPolling(outcomeId);
+        });
+    }
+    async watchTrades(outcomeId) {
+        if (this.closed)
+            throw new Error('Hunch watch connection is closed');
+        return new Promise((resolve, reject) => {
+            if (!this.tradeResolvers.has(outcomeId)) {
+                this.tradeResolvers.set(outcomeId, []);
+                this.tradeRejecters.set(outcomeId, []);
+            }
+            this.tradeResolvers.get(outcomeId).push(resolve);
+            this.tradeRejecters.get(outcomeId).push(reject);
+            if (!this.tradeTimers.has(outcomeId))
+                this.startTradePolling(outcomeId);
+        });
+    }
+    async close() {
+        this.closed = true;
+        for (const timer of this.orderBookTimers.values())
+            clearInterval(timer);
+        for (const timer of this.tradeTimers.values())
+            clearInterval(timer);
+        this.orderBookTimers.clear();
+        this.tradeTimers.clear();
+        this.orderBookResolvers.clear();
+        this.orderBookRejecters.clear();
+        this.tradeResolvers.clear();
+        this.tradeRejecters.clear();
+        this.seenTradeIds.clear();
+    }
+    startOrderBookPolling(id) {
+        const poll = async () => {
+            try {
+                const book = await this.fetchOrderBook(id);
+                this.orderBookFailureCount.set(id, 0);
+                const resolvers = this.orderBookResolvers.get(id) || [];
+                this.orderBookResolvers.set(id, []);
+                this.orderBookRejecters.set(id, []);
+                for (const resolve of resolvers)
+                    resolve(book);
+            }
+            catch (error) {
+                this.handleFailure(id, error, 'watchOrderBook', this.orderBookFailureCount, this.orderBookTimers, this.orderBookResolvers, this.orderBookRejecters);
+            }
+        };
+        poll();
+        this.orderBookTimers.set(id, setInterval(poll, this.pollInterval));
+    }
+    startTradePolling(id) {
+        const poll = async () => {
+            try {
+                const trades = await this.fetchTrades(id, 50);
+                let seen = this.seenTradeIds.get(id);
+                if (!seen) {
+                    seen = new Set();
+                    this.seenTradeIds.set(id, seen);
+                }
+                const fresh = trades.filter((t) => !seen.has(t.id));
+                for (const t of fresh)
+                    seen.add(t.id);
+                this.tradeFailureCount.set(id, 0);
+                const resolvers = this.tradeResolvers.get(id) || [];
+                this.tradeResolvers.set(id, []);
+                this.tradeRejecters.set(id, []);
+                for (const resolve of resolvers)
+                    resolve(fresh);
+            }
+            catch (error) {
+                this.handleFailure(id, error, 'watchTrades', this.tradeFailureCount, this.tradeTimers, this.tradeResolvers, this.tradeRejecters);
+            }
+        };
+        poll();
+        this.tradeTimers.set(id, setInterval(poll, this.pollInterval));
+    }
+    handleFailure(id, error, label, failures, timers, resolvers, rejecters) {
+        const count = (failures.get(id) || 0) + 1;
+        failures.set(id, count);
+        logger_1.logger.warn(`Hunch ${label} poll failed for outcomeId=${id} (consecutive failures: ${count})`, {
+            error: String(error),
+        });
+        if (count >= MAX_CONSECUTIVE_FAILURES) {
+            const timer = timers.get(id);
+            if (timer)
+                clearInterval(timer);
+            timers.delete(id);
+            failures.delete(id);
+            const rej = rejecters.get(id) || [];
+            resolvers.set(id, []);
+            rejecters.set(id, []);
+            for (const reject of rej)
+                reject(error);
+        }
+    }
+}
+exports.HunchWebSocket = HunchWebSocket;

package/dist/exchanges/hyperliquid/auth.js

@@ -46,12 +46,25 @@ function convertLargeInts(obj) {
     }
     return obj;
 }
+// ponytail: msgpackr encodes positive BigInts as int64 (0xd3); HL's server uses
+// Python's msgpack which encodes the same value as uint64 (0xcf). Post-process the
+// packed bytes to flip d3 → cf for non-negative payloads. HL actions never carry
+// negative integers (oids, nonces, asset ids are all >= 0), so this is safe.
+function fixInt64ToUint64(bytes) {
+    const out = Buffer.from(bytes);
+    for (let i = 0; i < out.length - 8; i++) {
+        if (out[i] === 0xd3 && (out[i + 1] & 0x80) === 0) {
+            out[i] = 0xcf;
+        }
+    }
+    return out;
+}
 // ----------------------------------------------------------------------------
 // Action hash -- constructs the connectionId for the phantom agent
 // ----------------------------------------------------------------------------
 function computeActionHash(action, vaultAddress, nonce) {
-    // 1. msgpack-encode the action (large ints as int64)
-    const actionBytes = packr.pack(convertLargeInts(action));
+    // 1. msgpack-encode the action; coerce positive int64 to uint64 to match HL's server (Python msgpack)
+    const actionBytes = fixInt64ToUint64(packr.pack(convertLargeInts(action)));
     // 2. nonce as 8 bytes big-endian
     const nonceBytes = Buffer.alloc(8);
     nonceBytes.writeBigUInt64BE(BigInt(nonce));

package/dist/exchanges/hyperliquid/fetcher.d.ts

@@ -126,10 +126,28 @@ export interface HyperliquidRawUserState {
     time?: number;
     withdrawable: string;
 }
+export interface HyperliquidRawSpotBalance {
+    coin: string;
+    token: number;
+    total: string;
+    hold: string;
+    entryNtl: string;
+}
+export interface HyperliquidRawSpotState {
+    balances: HyperliquidRawSpotBalance[];
+}
+export interface HyperliquidRawSpotAssetCtx {
+    coin: string;
+    dayNtlVlm: string;
+    prevDayPx?: string;
+    markPx?: string;
+    midPx?: string;
+}
 export interface HyperliquidRawOutcomeWithQuestion {
     outcome: HyperliquidRawOutcome;
     question: HyperliquidRawQuestion | undefined;
     midPrice: string | undefined;
+    volume24h?: number;
 }
 export declare class HyperliquidFetcher implements IExchangeFetcher<HyperliquidRawOutcomeWithQuestion, HyperliquidRawQuestion> {
     private readonly ctx;
@@ -140,11 +158,18 @@ export declare class HyperliquidFetcher implements IExchangeFetcher<HyperliquidR
     fetchRawEvents(params: EventFetchParams): Promise<HyperliquidRawQuestion[]>;
     fetchRawOrderBook(marketId: string): Promise<HyperliquidRawL2Book>;
     fetchRawOHLCV(marketId: string, params: OHLCVParams): Promise<HyperliquidRawCandle[]>;
-    fetchRawTrades(marketId: string, _params: TradesParams): Promise<HyperliquidRawTrade[]>;
+    fetchRawTrades(marketId: string, params: TradesParams): Promise<HyperliquidRawTrade[]>;
     fetchRawUserFills(walletAddress: string): Promise<HyperliquidRawFill[]>;
     fetchRawOpenOrders(walletAddress: string): Promise<HyperliquidRawOpenOrder[]>;
+    fetchRawSpotState(walletAddress: string): Promise<HyperliquidRawSpotState>;
     fetchRawUserState(walletAddress: string): Promise<HyperliquidRawUserState>;
     fetchOutcomeMeta(): Promise<HyperliquidRawOutcomeMeta>;
     fetchAllMids(): Promise<HyperliquidRawMid>;
+    /**
+     * Build a map of outcomeId -> 24h notional volume (Yes leg + No leg)
+     * by reading spotMetaAndAssetCtxs, where outcome legs appear as
+     * coin "#<encoding>" with `dayNtlVlm` in USDC.
+     */
+    fetchOutcomeVolumeMap(): Promise<Map<number, number>>;
     private getMidForOutcome;
 }

package/dist/exchanges/hyperliquid/fetcher.js

@@ -25,9 +25,10 @@ class HyperliquidFetcher {
     }
     // -- Markets (outcomes) ----------------------------------------------------
     async fetchRawMarkets(params) {
-        const [meta, mids] = await Promise.all([
+        const [meta, mids, volumeMap] = await Promise.all([
             this.fetchOutcomeMeta(),
             this.fetchAllMids(),
+            this.fetchOutcomeVolumeMap(),
         ]);
         const questionMap = new Map();
         for (const q of meta.questions) {
@@ -39,6 +40,7 @@ class HyperliquidFetcher {
             outcome,
             question: questionMap.get(outcome.outcome),
             midPrice: this.getMidForOutcome(mids, outcome.outcome),
+            volume24h: volumeMap.get(outcome.outcome),
         }));
         // Filter settled outcomes out by default (active only)
         if (!params?.status || params.status === 'active') {
@@ -56,6 +58,21 @@ class HyperliquidFetcher {
             results = results.filter(r => r.outcome.name.toLowerCase().includes(lowerQuery) ||
                 r.outcome.description.toLowerCase().includes(lowerQuery));
         }
+        // Direct lookup by marketId (canonical or outcome-token form)
+        if (params?.marketId) {
+            try {
+                const targetOutcomeId = (0, utils_1.fromMarketId)(String(params.marketId));
+                results = results.filter(r => r.outcome.outcome === targetOutcomeId);
+            }
+            catch {
+                results = [];
+            }
+        }
+        // Filter by parent eventId (HL question number)
+        if (params?.eventId !== undefined && params.eventId !== null) {
+            const targetEventId = String(params.eventId);
+            results = results.filter(r => r.question && String(r.question.question) === targetEventId);
+        }
         // Limit
         const limit = params?.limit || 250000;
         const offset = params?.offset || 0;
@@ -65,6 +82,11 @@ class HyperliquidFetcher {
     async fetchRawEvents(params) {
         const meta = await this.fetchOutcomeMeta();
         let results = [...meta.questions];
+        // Direct lookup by eventId (HL question number)
+        if (params?.eventId !== undefined && params.eventId !== null) {
+            const targetEventId = String(params.eventId);
+            results = results.filter(q => String(q.question) === targetEventId);
+        }
         // Filter by query
         if (params?.query) {
             const lowerQuery = params.query.toLowerCase();
@@ -92,16 +114,20 @@ class HyperliquidFetcher {
         const now = Date.now();
         const startTime = params.start ? params.start.getTime() : now - 24 * 60 * 60 * 1000;
         const endTime = params.end ? params.end.getTime() : now;
-        return this.postInfo({
+        const raw = await this.postInfo({
             type: 'candleSnapshot',
             req: { coin, interval: params.resolution || '1h', startTime, endTime },
         });
+        // ponytail: HL returns the full window; honor caller's limit by trimming to the most recent N
+        return params.limit && raw.length > params.limit ? raw.slice(-params.limit) : raw;
     }
     // -- Trades ----------------------------------------------------------------
-    async fetchRawTrades(marketId, _params) {
+    async fetchRawTrades(marketId, params) {
         const outcomeId = (0, utils_1.fromMarketId)(marketId);
         const coin = (0, utils_1.toCoinNotation)(outcomeId, 'yes');
-        return this.postInfo({ type: 'recentTrades', coin });
+        const raw = await this.postInfo({ type: 'recentTrades', coin });
+        // ponytail: HL recentTrades returns a fixed page; honor caller's limit (most recent N)
+        return params?.limit && raw.length > params.limit ? raw.slice(0, params.limit) : raw;
     }
     // -- User data -------------------------------------------------------------
     async fetchRawUserFills(walletAddress) {
@@ -116,6 +142,12 @@ class HyperliquidFetcher {
             user: walletAddress,
         });
     }
+    async fetchRawSpotState(walletAddress) {
+        return this.postInfo({
+            type: 'spotClearinghouseState',
+            user: walletAddress,
+        });
+    }
     async fetchRawUserState(walletAddress) {
         return this.postInfo({
             type: 'clearinghouseState',
@@ -129,6 +161,36 @@ class HyperliquidFetcher {
     async fetchAllMids() {
         return this.postInfo({ type: 'allMids' });
     }
+    /**
+     * Build a map of outcomeId -> 24h notional volume (Yes leg + No leg)
+     * by reading spotMetaAndAssetCtxs, where outcome legs appear as
+     * coin "#<encoding>" with `dayNtlVlm` in USDC.
+     */
+    async fetchOutcomeVolumeMap() {
+        const map = new Map();
+        try {
+            const resp = await this.postInfo({ type: 'spotMetaAndAssetCtxs' });
+            const ctxs = Array.isArray(resp) ? resp[1] : undefined;
+            if (!Array.isArray(ctxs))
+                return map;
+            for (const ctx of ctxs) {
+                if (!ctx?.coin || !ctx.coin.startsWith('#'))
+                    continue;
+                const vol = parseFloat(ctx.dayNtlVlm);
+                if (!Number.isFinite(vol))
+                    continue;
+                const encoding = parseInt(ctx.coin.slice(1), 10);
+                if (!Number.isFinite(encoding))
+                    continue;
+                const { outcomeId } = (0, utils_1.fromCoinEncoding)(encoding);
+                map.set(outcomeId, (map.get(outcomeId) ?? 0) + vol);
+            }
+        }
+        catch {
+            // ponytail: best-effort volume enrichment; if spotMetaAndAssetCtxs is unreachable, return empty map and callers fall back to 0
+        }
+        return map;
+    }
     getMidForOutcome(mids, outcomeId) {
         const midKey = (0, utils_1.toMidKey)(outcomeId);
         return mids[midKey];

package/dist/exchanges/hyperliquid/index.d.ts

@@ -20,12 +20,15 @@ export declare class HyperliquidExchange extends PredictionMarketExchange {
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     fetchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
-    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchOrderBooks(outcomeIds: string[]): Promise<Record<string, OrderBook>>;
+    fetchOHLCV(outcomeId: string, params?: OHLCVParams): Promise<PriceCandle[]>;
     fetchTrades(outcomeId: string, params?: TradesParams): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;
     fetchPositions(): Promise<Position[]>;
     fetchOpenOrders(): Promise<Order[]>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    fetchClosedOrders(): Promise<Order[]>;
+    fetchAllOrders(): Promise<Order[]>;
     buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
     submitOrder(built: BuiltOrder): Promise<Order>;
     createOrder(params: CreateOrderParams): Promise<Order>;