pmxt-core 2.39.1 → 2.40.1

package/dist/exchanges/baozi/fetcher.js

@@ -36,24 +36,34 @@ class BaoziFetcher {
                 }),
             ]);
             const markets = [];
+            let booleanSkipped = 0;
             for (const account of booleanAccounts) {
                 try {
                     const parsed = (0, utils_1.parseMarket)(account.account.data);
                     markets.push({ pubkey: account.pubkey.toString(), parsed });
                 }
-                catch {
-                    // Skip malformed accounts
+                catch (parseError) {
+                    booleanSkipped++;
+                    console.warn(`[Baozi] fetchRawMarkets: failed to parse boolean market account pubkey=${account.pubkey.toString()}:`, parseError);
                 }
             }
+            if (booleanSkipped > 0) {
+                console.warn(`[Baozi] fetchRawMarkets: skipped ${booleanSkipped} malformed boolean market account(s) out of ${booleanAccounts.length}`);
+            }
+            let raceSkipped = 0;
             for (const account of raceAccounts) {
                 try {
                     const parsed = (0, utils_1.parseRaceMarket)(account.account.data);
                     markets.push({ pubkey: account.pubkey.toString(), parsed });
                 }
-                catch {
-                    // Skip malformed accounts
+                catch (parseError) {
+                    raceSkipped++;
+                    console.warn(`[Baozi] fetchRawMarkets: failed to parse race market account pubkey=${account.pubkey.toString()}:`, parseError);
                 }
             }
+            if (raceSkipped > 0) {
+                console.warn(`[Baozi] fetchRawMarkets: skipped ${raceSkipped} malformed race market account(s) out of ${raceAccounts.length}`);
+            }
             marketsCache.set(markets);
             return markets;
         }
@@ -114,25 +124,35 @@ class BaoziFetcher {
                 }),
             ]);
             const booleanPositions = [];
+            let boolPosSkipped = 0;
             for (const account of booleanAccounts) {
                 try {
                     const parsed = (0, utils_1.parseUserPosition)(account.account.data);
                     booleanPositions.push({ pubkey: account.pubkey.toString(), parsed });
                 }
-                catch {
-                    // Skip malformed
+                catch (parseError) {
+                    boolPosSkipped++;
+                    console.warn(`[Baozi] fetchRawUserPositions: failed to parse boolean position account pubkey=${account.pubkey.toString()}:`, parseError);
                 }
             }
+            if (boolPosSkipped > 0) {
+                console.warn(`[Baozi] fetchRawUserPositions: skipped ${boolPosSkipped} malformed boolean position account(s) out of ${booleanAccounts.length}`);
+            }
             const racePositions = [];
+            let racePosSkipped = 0;
             for (const account of raceAccounts) {
                 try {
                     const parsed = (0, utils_1.parseRacePosition)(account.account.data);
                     racePositions.push({ pubkey: account.pubkey.toString(), parsed });
                 }
-                catch {
-                    // Skip malformed
+                catch (parseError) {
+                    racePosSkipped++;
+                    console.warn(`[Baozi] fetchRawUserPositions: failed to parse race position account pubkey=${account.pubkey.toString()}:`, parseError);
                 }
             }
+            if (racePosSkipped > 0) {
+                console.warn(`[Baozi] fetchRawUserPositions: skipped ${racePosSkipped} malformed race position account(s) out of ${raceAccounts.length}`);
+            }
             return { booleanPositions, racePositions };
         }
         catch (error) {

package/dist/exchanges/baozi/index.js

@@ -108,8 +108,9 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
                                 marketLookup.set(marketPdaStr, unified);
                         }
                     }
-                    catch {
-                        // Use defaults if market fetch fails
+                    catch (error) {
+                        console.warn(`[Baozi] fetchPositions: failed to fetch boolean market account for PDA=${marketPdaStr}:`, error);
+                        throw error;
                     }
                 }
             }
@@ -127,8 +128,9 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
                                 marketLookup.set(racePdaStr, unified);
                         }
                     }
-                    catch {
-                        // Use defaults if market fetch fails
+                    catch (error) {
+                        console.warn(`[Baozi] fetchPositions: failed to fetch race market account for PDA=${racePdaStr}:`, error);
+                        throw error;
                     }
                 }
             }

package/dist/exchanges/gemini-titan/auth.d.ts

@@ -0,0 +1,34 @@
+import { ExchangeCredentials } from '../../BaseExchange';
+/**
+ * Gemini HMAC-SHA384 authentication.
+ *
+ * Gemini's prediction market API uses header-based auth where the POST body
+ * is always empty — the actual payload is base64-encoded and placed in the
+ * X-GEMINI-PAYLOAD header, with an HMAC-SHA384 signature.
+ */
+export declare class GeminiAuth {
+    private readonly apiKey;
+    private readonly apiSecret;
+    private lastNonce;
+    constructor(credentials: ExchangeCredentials);
+    /**
+     * Generate a strictly monotonic nonce.
+     * Uses Date.now() but ensures it never repeats even if called
+     * within the same millisecond.
+     */
+    nonce(): number;
+    /**
+     * Build the three authentication headers for a given payload object.
+     *
+     * The payload must include `request` (endpoint path) and `nonce`.
+     * Additional fields (symbol, side, etc.) are included for order requests.
+     */
+    buildHeaders(payload: Record<string, unknown>): Record<string, string>;
+    /**
+     * Build WebSocket handshake authentication headers.
+     *
+     * WebSocket auth uses a time-based nonce (seconds since epoch)
+     * as the payload, not a JSON object.
+     */
+    buildWsHeaders(): Record<string, string>;
+}

package/dist/exchanges/gemini-titan/auth.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiAuth = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const errors_1 = require("../../errors");
+/**
+ * Gemini HMAC-SHA384 authentication.
+ *
+ * Gemini's prediction market API uses header-based auth where the POST body
+ * is always empty — the actual payload is base64-encoded and placed in the
+ * X-GEMINI-PAYLOAD header, with an HMAC-SHA384 signature.
+ */
+class GeminiAuth {
+    apiKey;
+    apiSecret;
+    lastNonce = 0;
+    constructor(credentials) {
+        if (!credentials.apiKey || !credentials.apiSecret) {
+            throw new errors_1.AuthenticationError('Gemini Titan trading requires both apiKey and apiSecret.', 'GeminiTitan');
+        }
+        this.apiKey = credentials.apiKey;
+        this.apiSecret = credentials.apiSecret;
+    }
+    /**
+     * Generate a strictly monotonic nonce.
+     * Uses Date.now() but ensures it never repeats even if called
+     * within the same millisecond.
+     */
+    nonce() {
+        const now = Date.now();
+        this.lastNonce = Math.max(now, this.lastNonce + 1);
+        return this.lastNonce;
+    }
+    /**
+     * Build the three authentication headers for a given payload object.
+     *
+     * The payload must include `request` (endpoint path) and `nonce`.
+     * Additional fields (symbol, side, etc.) are included for order requests.
+     */
+    buildHeaders(payload) {
+        const jsonPayload = JSON.stringify(payload);
+        const b64Payload = Buffer.from(jsonPayload).toString('base64');
+        const signature = crypto_1.default
+            .createHmac('sha384', this.apiSecret)
+            .update(b64Payload)
+            .digest('hex');
+        return {
+            'Content-Type': 'text/plain',
+            'Content-Length': '0',
+            'X-GEMINI-APIKEY': this.apiKey,
+            'X-GEMINI-PAYLOAD': b64Payload,
+            'X-GEMINI-SIGNATURE': signature,
+            'Cache-Control': 'no-cache',
+        };
+    }
+    /**
+     * Build WebSocket handshake authentication headers.
+     *
+     * WebSocket auth uses a time-based nonce (seconds since epoch)
+     * as the payload, not a JSON object.
+     */
+    buildWsHeaders() {
+        const nonce = Math.floor(Date.now() / 1000).toString();
+        const b64Payload = Buffer.from(nonce).toString('base64');
+        const signature = crypto_1.default
+            .createHmac('sha384', this.apiSecret)
+            .update(b64Payload)
+            .digest('hex');
+        return {
+            'X-GEMINI-APIKEY': this.apiKey,
+            'X-GEMINI-NONCE': nonce,
+            'X-GEMINI-PAYLOAD': b64Payload,
+            'X-GEMINI-SIGNATURE': signature,
+        };
+    }
+}
+exports.GeminiAuth = GeminiAuth;

package/dist/exchanges/gemini-titan/config.d.ts

@@ -0,0 +1,15 @@
+export declare const DEFAULT_GEMINI_BASE_URL = "https://api.gemini.com";
+export declare const GEMINI_SANDBOX_BASE_URL = "https://api.sandbox.gemini.com";
+export declare const GEMINI_WS_URL = "wss://ws.gemini.com";
+export declare const GEMINI_SANDBOX_WS_URL = "wss://ws.sandbox.gemini.com";
+export declare const INSTRUMENT_PREFIX = "GEMI-";
+export declare const MIN_PRICE = 0.01;
+export declare const MAX_PRICE = 0.99;
+export declare const TICK_SIZE = 0.01;
+export declare const PAYOUT_PER_CONTRACT = 1;
+export interface GeminiApiConfig {
+    baseUrl: string;
+    wsUrl: string;
+    sandbox: boolean;
+}
+export declare function getGeminiConfig(baseUrlOverride?: string, sandbox?: boolean): GeminiApiConfig;

package/dist/exchanges/gemini-titan/config.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAYOUT_PER_CONTRACT = exports.TICK_SIZE = exports.MAX_PRICE = exports.MIN_PRICE = exports.INSTRUMENT_PREFIX = exports.GEMINI_SANDBOX_WS_URL = exports.GEMINI_WS_URL = exports.GEMINI_SANDBOX_BASE_URL = exports.DEFAULT_GEMINI_BASE_URL = void 0;
+exports.getGeminiConfig = getGeminiConfig;
+exports.DEFAULT_GEMINI_BASE_URL = 'https://api.gemini.com';
+exports.GEMINI_SANDBOX_BASE_URL = 'https://api.sandbox.gemini.com';
+exports.GEMINI_WS_URL = 'wss://ws.gemini.com';
+exports.GEMINI_SANDBOX_WS_URL = 'wss://ws.sandbox.gemini.com';
+// All Gemini prediction market instrument symbols use this prefix
+exports.INSTRUMENT_PREFIX = 'GEMI-';
+// Gemini prediction market prices are in the range [0.01, 0.99]
+exports.MIN_PRICE = 0.01;
+exports.MAX_PRICE = 0.99;
+exports.TICK_SIZE = 0.01;
+// Payout is always $1.00 per winning contract
+exports.PAYOUT_PER_CONTRACT = 1.0;
+function getGeminiConfig(baseUrlOverride, sandbox) {
+    const isSandbox = sandbox ?? false;
+    return {
+        baseUrl: baseUrlOverride ?? (isSandbox ? exports.GEMINI_SANDBOX_BASE_URL : exports.DEFAULT_GEMINI_BASE_URL),
+        wsUrl: isSandbox ? exports.GEMINI_SANDBOX_WS_URL : exports.GEMINI_WS_URL,
+        sandbox: isSandbox,
+    };
+}

package/dist/exchanges/gemini-titan/errors.d.ts

@@ -0,0 +1,20 @@
+import { ErrorMapper } from '../../utils/error-mapper';
+import { BadRequest } from '../../errors';
+/**
+ * Maps Gemini Titan API errors to PMXT unified error classes.
+ *
+ * Gemini returns errors as JSON:
+ *   { result: "error", reason: "InvalidSignature", message: "..." }
+ *
+ * Common reasons:
+ *   - InvalidSignature -> AuthenticationError
+ *   - InsufficientFunds -> InsufficientFunds
+ *   - InvalidQuantity, InvalidPrice, MarketNotOpen -> InvalidOrder
+ */
+export declare class GeminiErrorMapper extends ErrorMapper {
+    constructor();
+    protected extractErrorMessage(error: any): string;
+    protected mapBadRequestError(message: string, data: any): BadRequest;
+    mapError(error: any): ReturnType<ErrorMapper['mapError']>;
+}
+export declare const geminiErrorMapper: GeminiErrorMapper;

package/dist/exchanges/gemini-titan/errors.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiErrorMapper = exports.GeminiErrorMapper = void 0;
+const axios_1 = __importDefault(require("axios"));
+const error_mapper_1 = require("../../utils/error-mapper");
+const errors_1 = require("../../errors");
+/**
+ * Maps Gemini Titan API errors to PMXT unified error classes.
+ *
+ * Gemini returns errors as JSON:
+ *   { result: "error", reason: "InvalidSignature", message: "..." }
+ *
+ * Common reasons:
+ *   - InvalidSignature -> AuthenticationError
+ *   - InsufficientFunds -> InsufficientFunds
+ *   - InvalidQuantity, InvalidPrice, MarketNotOpen -> InvalidOrder
+ */
+class GeminiErrorMapper extends error_mapper_1.ErrorMapper {
+    constructor() {
+        super('GeminiTitan');
+    }
+    extractErrorMessage(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.data) {
+            const data = error.response.data;
+            if (typeof data === 'string') {
+                return `[${error.response.status}] ${data}`;
+            }
+            if (data.message) {
+                return `[${error.response.status}] ${data.message}`;
+            }
+            if (data.reason) {
+                return `[${error.response.status}] ${data.reason}`;
+            }
+        }
+        return super.extractErrorMessage(error);
+    }
+    mapBadRequestError(message, data) {
+        const reason = typeof data === 'object' && data?.reason
+            ? String(data.reason)
+            : '';
+        const lowerReason = reason.toLowerCase();
+        const lowerMessage = message.toLowerCase();
+        if (lowerReason.includes('insufficientfunds') || lowerMessage.includes('insufficient')) {
+            return new errors_1.InsufficientFunds(message, this.exchangeName);
+        }
+        if (lowerReason.includes('invalidquantity') ||
+            lowerReason.includes('invalidprice') ||
+            lowerReason.includes('limitpriceofftick') ||
+            lowerReason.includes('invalidstopprice') ||
+            lowerReason.includes('marketnotopen') ||
+            lowerReason.includes('unknowninstrument') ||
+            lowerReason.includes('duplicateorder')) {
+            return new errors_1.InvalidOrder(message, this.exchangeName);
+        }
+        if (lowerReason.includes('invalidsignature') ||
+            lowerReason.includes('invalidapikey') ||
+            lowerMessage.includes('terms_not_accepted')) {
+            return new errors_1.AuthenticationError(message, this.exchangeName);
+        }
+        return super.mapBadRequestError(message, data);
+    }
+    mapError(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.status === 429) {
+            const retryAfter = error.response.headers?.['retry-after'];
+            const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : undefined;
+            return new errors_1.RateLimitExceeded(this.extractErrorMessage(error), retryAfterSeconds, this.exchangeName);
+        }
+        return super.mapError(error);
+    }
+}
+exports.GeminiErrorMapper = GeminiErrorMapper;
+exports.geminiErrorMapper = new GeminiErrorMapper();

package/dist/exchanges/gemini-titan/fetcher.d.ts

@@ -0,0 +1,26 @@
+import { MarketFilterParams, EventFetchParams } from '../../BaseExchange';
+import { IExchangeFetcher, FetcherContext } from '../interfaces';
+import { GeminiAuth } from './auth';
+import { GeminiRawEvent, GeminiRawOrder, GeminiRawPosition, GeminiRawOrderBook } from './types';
+export declare class GeminiFetcher implements IExchangeFetcher<GeminiRawEvent, GeminiRawEvent> {
+    private readonly ctx;
+    private readonly baseUrl;
+    private readonly auth;
+    private symbolToEventTicker;
+    constructor(ctx: FetcherContext, baseUrl: string, auth?: GeminiAuth);
+    fetchRawMarkets(params?: MarketFilterParams): Promise<GeminiRawEvent[]>;
+    fetchRawEvents(params: EventFetchParams): Promise<GeminiRawEvent[]>;
+    fetchRawSingleEvent(eventTicker: string): Promise<GeminiRawEvent>;
+    fetchRawOrderBook(instrumentSymbol: string): Promise<GeminiRawOrderBook | undefined>;
+    getEventTickerForSymbol(instrumentSymbol: string): string | undefined;
+    submitRawOrder(payload: Record<string, unknown>): Promise<GeminiRawOrder>;
+    cancelRawOrder(orderId: number): Promise<{
+        result: string;
+        message: string;
+    }>;
+    fetchRawActiveOrders(symbol?: string): Promise<GeminiRawOrder[]>;
+    fetchRawOrderHistory(): Promise<GeminiRawOrder[]>;
+    fetchRawPositions(): Promise<GeminiRawPosition[]>;
+    private get;
+    private postAuthenticated;
+}

package/dist/exchanges/gemini-titan/fetcher.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiFetcher = void 0;
+const errors_1 = require("./errors");
+// ----------------------------------------------------------------------------
+// Fetcher
+// ----------------------------------------------------------------------------
+class GeminiFetcher {
+    ctx;
+    baseUrl;
+    auth;
+    // Index mapping instrumentSymbol -> eventTicker, built during fetchRawEvents
+    symbolToEventTicker = new Map();
+    constructor(ctx, baseUrl, auth) {
+        this.ctx = ctx;
+        this.baseUrl = baseUrl;
+        this.auth = auth;
+    }
+    // -- Public data -----------------------------------------------------------
+    async fetchRawMarkets(params) {
+        return this.fetchRawEvents(params ?? {});
+    }
+    async fetchRawEvents(params) {
+        const allEvents = [];
+        const pageSize = 500;
+        let offset = params.offset ?? 0;
+        const maxResults = params.limit ?? 250000;
+        while (allEvents.length < maxResults) {
+            const queryParams = {
+                limit: String(Math.min(pageSize, maxResults - allEvents.length)),
+                offset: String(offset),
+            };
+            if (params.status && params.status !== 'all') {
+                queryParams.status = params.status === 'active' ? 'active' : params.status;
+            }
+            else if (!params.status) {
+                queryParams.status = 'active';
+            }
+            if (params.category) {
+                queryParams.category = params.category;
+            }
+            if (params.query) {
+                queryParams.search = params.query;
+            }
+            const response = await this.get('/v1/prediction-markets/events', queryParams);
+            const events = response.data;
+            if (events.length === 0)
+                break;
+            // Build the instrumentSymbol -> eventTicker index
+            for (const event of events) {
+                for (const contract of event.contracts) {
+                    this.symbolToEventTicker.set(contract.instrumentSymbol, event.ticker);
+                }
+            }
+            allEvents.push(...events);
+            // Check if we've fetched all available
+            if (allEvents.length >= response.pagination.total)
+                break;
+            offset += events.length;
+        }
+        return allEvents;
+    }
+    async fetchRawSingleEvent(eventTicker) {
+        return this.get(`/v1/prediction-markets/events/${encodeURIComponent(eventTicker)}`);
+    }
+    async fetchRawOrderBook(instrumentSymbol) {
+        const eventTicker = this.getEventTickerForSymbol(instrumentSymbol);
+        if (!eventTicker) {
+            throw new Error(`Cannot fetch order book: no event ticker found for ${instrumentSymbol}. ` +
+                'Call fetchMarkets first to build the symbol index.');
+        }
+        const event = await this.fetchRawSingleEvent(eventTicker);
+        // The REST API does not expose a full order book — construct a
+        // single-level book from the contract's best bid/ask prices.
+        // Full depth is only available via the WebSocket @depth streams.
+        const contract = event.contracts.find(c => c.instrumentSymbol === instrumentSymbol);
+        if (!contract?.prices)
+            return undefined;
+        const { bestBid, bestAsk } = contract.prices;
+        const bids = bestBid
+            ? [{ price: bestBid, size: '0' }]
+            : [];
+        const asks = bestAsk
+            ? [{ price: bestAsk, size: '0' }]
+            : [];
+        return { bids, asks, timestamp: Date.now() };
+    }
+    getEventTickerForSymbol(instrumentSymbol) {
+        return this.symbolToEventTicker.get(instrumentSymbol);
+    }
+    // -- Authenticated endpoints -----------------------------------------------
+    async submitRawOrder(payload) {
+        return this.postAuthenticated('/v1/prediction-markets/order', payload);
+    }
+    async cancelRawOrder(orderId) {
+        return this.postAuthenticated('/v1/prediction-markets/order/cancel', { orderId });
+    }
+    async fetchRawActiveOrders(symbol) {
+        const extra = {};
+        if (symbol)
+            extra.symbol = symbol;
+        const response = await this.postAuthenticated('/v1/prediction-markets/orders/active', extra);
+        return response.orders;
+    }
+    async fetchRawOrderHistory() {
+        const response = await this.postAuthenticated('/v1/prediction-markets/orders/history', {});
+        return Array.isArray(response) ? response : [];
+    }
+    async fetchRawPositions() {
+        const response = await this.postAuthenticated('/v1/prediction-markets/positions', {});
+        return response.positions;
+    }
+    // -- HTTP helpers ----------------------------------------------------------
+    async get(path, params) {
+        try {
+            const url = new URL(path, this.baseUrl);
+            if (params) {
+                for (const [key, value] of Object.entries(params)) {
+                    url.searchParams.set(key, value);
+                }
+            }
+            const response = await this.ctx.http.get(url.toString());
+            return response.data;
+        }
+        catch (error) {
+            throw errors_1.geminiErrorMapper.mapError(error);
+        }
+    }
+    async postAuthenticated(path, extraFields) {
+        if (!this.auth) {
+            throw new Error('Authentication required. Provide apiKey and apiSecret.');
+        }
+        const payload = {
+            request: path,
+            nonce: this.auth.nonce(),
+            ...extraFields,
+        };
+        const headers = this.auth.buildHeaders(payload);
+        try {
+            const response = await this.ctx.http.post(`${this.baseUrl}${path}`, {}, { headers });
+            return response.data;
+        }
+        catch (error) {
+            throw errors_1.geminiErrorMapper.mapError(error);
+        }
+    }
+}
+exports.GeminiFetcher = GeminiFetcher;

package/dist/exchanges/gemini-titan/index.d.ts

@@ -0,0 +1,31 @@
+import { PredictionMarketExchange, MarketFilterParams, EventFetchParams, ExchangeCredentials } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, OrderBook, Trade, Order, Position, CreateOrderParams, BuiltOrder } from '../../types';
+export interface GeminiTitanExchangeOptions {
+    credentials?: ExchangeCredentials;
+    sandbox?: boolean;
+}
+export declare class GeminiTitanExchange extends PredictionMarketExchange {
+    private readonly config;
+    private readonly fetcher;
+    private readonly normalizer;
+    private readonly geminiAuth?;
+    private geminiWs?;
+    constructor(credentials?: ExchangeCredentials | GeminiTitanExchangeOptions);
+    get name(): string;
+    private requireAuth;
+    protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
+    submitOrder(built: BuiltOrder): Promise<Order>;
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    cancelOrder(orderId: string): Promise<Order>;
+    fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    fetchClosedOrders(): Promise<Order[]>;
+    fetchAllOrders(): Promise<Order[]>;
+    fetchPositions(): Promise<Position[]>;
+    private ensureWebSocket;
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    watchTrades(outcomeId: string): Promise<Trade[]>;
+    close(): Promise<void>;
+}