pmxt-core 2.3.0 → 2.4.0

package/dist/exchanges/probable/index.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProbableExchange = void 0;
+const BaseExchange_1 = require("../../BaseExchange");
+const fetchMarkets_1 = require("./fetchMarkets");
+const fetchEvents_1 = require("./fetchEvents");
+const fetchOrderBook_1 = require("./fetchOrderBook");
+const fetchOHLCV_1 = require("./fetchOHLCV");
+const fetchPositions_1 = require("./fetchPositions");
+const fetchTrades_1 = require("./fetchTrades");
+const auth_1 = require("./auth");
+const websocket_1 = require("./websocket");
+const errors_1 = require("./errors");
+const errors_2 = require("../../errors");
+const clob_1 = require("@prob/clob");
+const BSC_USDT_ADDRESS = '0x55d398326f99059fF775485246999027B3197955';
+class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
+    auth;
+    ws;
+    wsConfig;
+    constructor(credentials, wsConfig) {
+        super(credentials);
+        this.wsConfig = wsConfig;
+        if (credentials?.privateKey && credentials?.apiKey && credentials?.apiSecret && credentials?.passphrase) {
+            this.auth = new auth_1.ProbableAuth(credentials);
+        }
+    }
+    get name() {
+        return 'Probable';
+    }
+    ensureAuth() {
+        if (!this.auth) {
+            throw new errors_2.AuthenticationError('Trading operations require authentication. ' +
+                'Initialize ProbableExchange with credentials: new ProbableExchange({ privateKey: "0x...", apiKey: "...", apiSecret: "...", passphrase: "..." })', 'Probable');
+        }
+        return this.auth;
+    }
+    // --------------------------------------------------------------------------
+    // Market Data (read-only, no auth needed)
+    // --------------------------------------------------------------------------
+    async fetchMarketsImpl(params) {
+        return (0, fetchMarkets_1.fetchMarkets)(params);
+    }
+    async fetchEventsImpl(params) {
+        return (0, fetchEvents_1.fetchEvents)(params);
+    }
+    async getEventById(id) {
+        return (0, fetchEvents_1.fetchEventById)(id);
+    }
+    async getEventBySlug(slug) {
+        return (0, fetchEvents_1.fetchEventBySlug)(slug);
+    }
+    async fetchOrderBook(id) {
+        return (0, fetchOrderBook_1.fetchOrderBook)(id);
+    }
+    async fetchOHLCV(id, params) {
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params);
+    }
+    // --------------------------------------------------------------------------
+    // Trading Methods
+    // --------------------------------------------------------------------------
+    async createOrder(params) {
+        try {
+            const auth = this.ensureAuth();
+            const client = auth.getClobClient();
+            const side = params.side.toLowerCase() === 'buy' ? clob_1.OrderSide.Buy : clob_1.OrderSide.Sell;
+            let unsignedOrder;
+            if (params.type === 'market') {
+                unsignedOrder = await client.createMarketOrder({
+                    tokenId: params.outcomeId,
+                    size: params.amount,
+                    side,
+                });
+            }
+            else {
+                if (!params.price) {
+                    throw new Error('Price is required for limit orders');
+                }
+                unsignedOrder = await client.createLimitOrder({
+                    tokenId: params.outcomeId,
+                    price: params.price,
+                    size: params.amount,
+                    side,
+                });
+            }
+            if (params.fee !== undefined && params.fee !== null) {
+                unsignedOrder.feeRateBps = BigInt(params.fee);
+            }
+            const response = await client.postOrder(unsignedOrder);
+            // postOrder returns PostOrderResponse which can be success or error
+            if (response && 'code' in response && response.code !== undefined) {
+                throw new Error(response.msg || 'Order placement failed');
+            }
+            const orderResponse = response;
+            return {
+                id: String(orderResponse.orderId || orderResponse.id || ''),
+                marketId: params.marketId,
+                outcomeId: params.outcomeId,
+                side: params.side,
+                type: params.type,
+                price: params.price || parseFloat(orderResponse.price || '0'),
+                amount: params.amount,
+                status: 'open',
+                filled: parseFloat(orderResponse.executedQty || '0'),
+                remaining: params.amount - parseFloat(orderResponse.executedQty || '0'),
+                fee: params.fee,
+                timestamp: orderResponse.time || Date.now(),
+            };
+        }
+        catch (error) {
+            throw errors_1.probableErrorMapper.mapError(error);
+        }
+    }
+    /**
+     * Cancel an order.
+     * The Probable SDK requires both orderId and tokenId for cancellation.
+     * Pass a compound key as "orderId:tokenId" to provide both values.
+     */
+    async cancelOrder(orderId) {
+        try {
+            const auth = this.ensureAuth();
+            const client = auth.getClobClient();
+            const [actualOrderId, tokenId] = parseCompoundId(orderId);
+            if (!tokenId) {
+                throw new Error('Probable cancelOrder requires a compound ID in the format "orderId:tokenId". ' +
+                    'The tokenId (outcomeId) is required by the Probable SDK.');
+            }
+            await client.cancelOrder({
+                orderId: actualOrderId,
+                tokenId,
+            });
+            return {
+                id: actualOrderId,
+                marketId: 'unknown',
+                outcomeId: tokenId,
+                side: 'buy',
+                type: 'limit',
+                amount: 0,
+                status: 'cancelled',
+                filled: 0,
+                remaining: 0,
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            throw errors_1.probableErrorMapper.mapError(error);
+        }
+    }
+    /**
+     * Fetch a single order by ID.
+     * Pass a compound key as "orderId:tokenId" since the SDK requires both.
+     */
+    async fetchOrder(orderId) {
+        try {
+            const auth = this.ensureAuth();
+            const client = auth.getClobClient();
+            const [actualOrderId, tokenId] = parseCompoundId(orderId);
+            if (!tokenId) {
+                throw new Error('Probable fetchOrder requires a compound ID in the format "orderId:tokenId".');
+            }
+            const order = await client.getOrder({
+                orderId: actualOrderId,
+                tokenId,
+            });
+            if (!order || ('code' in order)) {
+                throw new Error(order?.msg || 'Order not found');
+            }
+            const o = order;
+            return {
+                id: String(o.orderId || o.id),
+                marketId: o.symbol || 'unknown',
+                outcomeId: o.tokenId || tokenId,
+                side: (o.side || '').toLowerCase(),
+                type: o.type === 'LIMIT' || o.timeInForce === 'GTC' ? 'limit' : 'market',
+                price: parseFloat(o.price || '0'),
+                amount: parseFloat(o.origQty || '0'),
+                status: mapOrderStatus(o.status),
+                filled: parseFloat(o.executedQty || '0'),
+                remaining: parseFloat(o.origQty || '0') - parseFloat(o.executedQty || '0'),
+                timestamp: o.time || o.updateTime || Date.now(),
+            };
+        }
+        catch (error) {
+            throw errors_1.probableErrorMapper.mapError(error);
+        }
+    }
+    async fetchOpenOrders(marketId) {
+        try {
+            const auth = this.ensureAuth();
+            const client = auth.getClobClient();
+            const params = {};
+            if (marketId) {
+                params.eventId = marketId;
+            }
+            const orders = await client.getOpenOrders(params);
+            const orderList = Array.isArray(orders) ? orders : orders?.data || [];
+            return orderList.map((o) => ({
+                id: String(o.orderId || o.id),
+                marketId: o.symbol || 'unknown',
+                outcomeId: o.tokenId || '',
+                side: (o.side || '').toLowerCase(),
+                type: 'limit',
+                price: parseFloat(o.price || '0'),
+                amount: parseFloat(o.origQty || '0'),
+                status: 'open',
+                filled: parseFloat(o.executedQty || '0'),
+                remaining: parseFloat(o.origQty || '0') - parseFloat(o.executedQty || '0'),
+                timestamp: o.time || o.updateTime || Date.now(),
+            }));
+        }
+        catch (error) {
+            throw errors_1.probableErrorMapper.mapError(error);
+        }
+    }
+    async fetchPositions() {
+        try {
+            const auth = this.ensureAuth();
+            const address = auth.getAddress();
+            return (0, fetchPositions_1.fetchPositions)(address);
+        }
+        catch (error) {
+            throw errors_1.probableErrorMapper.mapError(error);
+        }
+    }
+    async fetchBalance() {
+        try {
+            const auth = this.ensureAuth();
+            let total = 0;
+            try {
+                const { createPublicClient, http, parseAbi, formatUnits } = require('viem');
+                const { bsc } = require('viem/chains');
+                const publicClient = createPublicClient({
+                    chain: bsc,
+                    transport: http(),
+                });
+                const balance = await publicClient.readContract({
+                    address: BSC_USDT_ADDRESS,
+                    abi: parseAbi(['function balanceOf(address) view returns (uint256)']),
+                    functionName: 'balanceOf',
+                    args: [auth.getAddress()],
+                });
+                total = parseFloat(formatUnits(balance, 18));
+            }
+            catch (chainError) {
+                // On-chain check failed, return 0
+            }
+            // Calculate locked from open BUY orders
+            let locked = 0;
+            try {
+                const openOrders = await this.fetchOpenOrders();
+                for (const order of openOrders) {
+                    if (order.side === 'buy' && order.price) {
+                        locked += order.remaining * order.price;
+                    }
+                }
+            }
+            catch {
+                // If we can't fetch orders, locked stays 0
+            }
+            return [{
+                    currency: 'USDT',
+                    total,
+                    available: total - locked,
+                    locked,
+                }];
+        }
+        catch (error) {
+            throw errors_1.probableErrorMapper.mapError(error);
+        }
+    }
+    async fetchTrades(id, params) {
+        const auth = this.ensureAuth();
+        const client = auth.getClobClient();
+        return (0, fetchTrades_1.fetchTrades)(id, params, client);
+    }
+    // --------------------------------------------------------------------------
+    // WebSocket Streaming (public, no auth needed)
+    // --------------------------------------------------------------------------
+    async watchOrderBook(id, limit) {
+        if (!this.ws) {
+            this.ws = new websocket_1.ProbableWebSocket(this.wsConfig);
+        }
+        return this.ws.watchOrderBook(id);
+    }
+    async close() {
+        if (this.ws) {
+            await this.ws.close();
+            this.ws = undefined;
+        }
+    }
+}
+exports.ProbableExchange = ProbableExchange;
+/**
+ * Parse a compound ID in the format "orderId:tokenId".
+ * Returns [orderId, tokenId] where tokenId may be undefined.
+ */
+function parseCompoundId(compoundId) {
+    const colonIndex = compoundId.indexOf(':');
+    if (colonIndex === -1) {
+        return [compoundId, undefined];
+    }
+    return [compoundId.substring(0, colonIndex), compoundId.substring(colonIndex + 1)];
+}
+function mapOrderStatus(status) {
+    if (!status)
+        return 'open';
+    const lower = status.toLowerCase();
+    if (lower === 'new' || lower === 'open' || lower === 'partially_filled')
+        return 'open';
+    if (lower === 'filled' || lower === 'trade')
+        return 'filled';
+    if (lower === 'canceled' || lower === 'cancelled' || lower === 'expired')
+        return 'cancelled';
+    if (lower === 'rejected')
+        return 'rejected';
+    return 'open';
+}

package/dist/exchanges/probable/utils.d.ts

@@ -0,0 +1,9 @@
+import { UnifiedMarket, UnifiedEvent } from '../../types';
+export declare const BASE_URL = "https://market-api.probable.markets";
+export declare const CLOB_BASE_URL = "https://api.probable.markets/public/api/v1";
+export declare const SEARCH_PATH = "/public/api/v1/public-search/";
+export declare const EVENTS_PATH = "/public/api/v1/events/";
+export declare const MARKETS_PATH = "/public/api/v1/markets/";
+export declare function mapMarketToUnified(market: any, event?: any): UnifiedMarket | null;
+export declare function mapEventToUnified(event: any): UnifiedEvent | null;
+export declare function enrichMarketsWithPrices(markets: UnifiedMarket[]): Promise<void>;

package/dist/exchanges/probable/utils.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKETS_PATH = exports.EVENTS_PATH = exports.SEARCH_PATH = exports.CLOB_BASE_URL = exports.BASE_URL = void 0;
+exports.mapMarketToUnified = mapMarketToUnified;
+exports.mapEventToUnified = mapEventToUnified;
+exports.enrichMarketsWithPrices = enrichMarketsWithPrices;
+const market_utils_1 = require("../../utils/market-utils");
+const axios_1 = __importDefault(require("axios"));
+exports.BASE_URL = 'https://market-api.probable.markets';
+exports.CLOB_BASE_URL = 'https://api.probable.markets/public/api/v1';
+exports.SEARCH_PATH = '/public/api/v1/public-search/';
+exports.EVENTS_PATH = '/public/api/v1/events/';
+exports.MARKETS_PATH = '/public/api/v1/markets/';
+function mapMarketToUnified(market, event) {
+    if (!market)
+        return null;
+    const outcomes = [];
+    // Probable API provides tokens array with token_id and outcome label.
+    // The outcomes field is a JSON string like '["Yes","No"]'.
+    // Prices are not included in the search response.
+    if (market.tokens && Array.isArray(market.tokens)) {
+        for (const token of market.tokens) {
+            outcomes.push({
+                outcomeId: String(token.token_id),
+                marketId: String(market.id),
+                label: token.outcome || '',
+                price: 0,
+                priceChange24h: 0,
+            });
+        }
+    }
+    const um = {
+        marketId: String(market.id),
+        title: market.question || market.title || '',
+        description: market.description || '',
+        outcomes,
+        resolutionDate: market.endDate ? new Date(market.endDate) : new Date(),
+        volume24h: Number(market.volume24hr || 0),
+        volume: Number(market.volume || 0),
+        liquidity: Number(market.liquidity || 0),
+        openInterest: 0,
+        url: `https://probable.markets/markets/${market.market_slug || market.slug || market.id}`,
+        image: market.icon || event?.icon || event?.image || undefined,
+        category: event?.category || market.category || undefined,
+        tags: market.tags || event?.tags || [],
+    };
+    (0, market_utils_1.addBinaryOutcomes)(um);
+    return um;
+}
+function mapEventToUnified(event) {
+    if (!event)
+        return null;
+    const markets = [];
+    if (event.markets && Array.isArray(event.markets)) {
+        for (const market of event.markets) {
+            const mapped = mapMarketToUnified(market, event);
+            if (mapped)
+                markets.push(mapped);
+        }
+    }
+    return {
+        id: String(event.id),
+        title: event.title || '',
+        description: event.description || '',
+        slug: event.slug || '',
+        markets,
+        url: `https://probable.markets/events/${event.slug || event.id}`,
+        image: event.icon || event.image || undefined,
+        category: event.category || undefined,
+        tags: event.tags || [],
+    };
+}
+async function enrichMarketsWithPrices(markets) {
+    const outcomes = [];
+    for (const market of markets) {
+        for (const outcome of market.outcomes) {
+            if (outcome.outcomeId)
+                outcomes.push(outcome);
+        }
+    }
+    if (outcomes.length === 0)
+        return;
+    const results = await Promise.allSettled(outcomes.map(async (outcome) => {
+        const response = await axios_1.default.get(`${exports.CLOB_BASE_URL}/midpoint`, {
+            params: { token_id: outcome.outcomeId },
+        });
+        return { outcomeId: outcome.outcomeId, mid: Number(response.data?.mid ?? 0) };
+    }));
+    const priceMap = {};
+    for (const result of results) {
+        if (result.status === 'fulfilled') {
+            priceMap[result.value.outcomeId] = result.value.mid;
+        }
+    }
+    for (const market of markets) {
+        for (const outcome of market.outcomes) {
+            const price = priceMap[outcome.outcomeId];
+            if (price !== undefined)
+                outcome.price = price;
+        }
+        (0, market_utils_1.addBinaryOutcomes)(market);
+    }
+}

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

@@ -0,0 +1,27 @@
+import { OrderBook } from '../../types';
+export interface ProbableWebSocketConfig {
+    /** WebSocket URL (default: wss://ws.probable.markets/public/api/v1) */
+    wsUrl?: string;
+    /** Base URL for the CLOB client (default: https://api.probable.markets/public/api/v1) */
+    baseUrl?: string;
+    /** Chain ID (default: 56 for BSC mainnet) */
+    chainId?: number;
+}
+/**
+ * Probable WebSocket implementation for real-time order book streaming.
+ * Uses the @prob/clob SDK's subscribePublicStream (no auth required).
+ * Follows CCXT Pro-style async pattern with watchOrderBook().
+ */
+export declare class ProbableWebSocket {
+    private client?;
+    private config;
+    private orderBookResolvers;
+    private orderBooks;
+    private subscriptions;
+    constructor(config?: ProbableWebSocketConfig);
+    private ensureClient;
+    watchOrderBook(tokenId: string): Promise<OrderBook>;
+    private handleOrderBookUpdate;
+    private resolveOrderBook;
+    close(): Promise<void>;
+}

package/dist/exchanges/probable/websocket.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProbableWebSocket = void 0;
+/**
+ * Probable WebSocket implementation for real-time order book streaming.
+ * Uses the @prob/clob SDK's subscribePublicStream (no auth required).
+ * Follows CCXT Pro-style async pattern with watchOrderBook().
+ */
+class ProbableWebSocket {
+    client;
+    config;
+    orderBookResolvers = new Map();
+    orderBooks = new Map();
+    subscriptions = new Map();
+    constructor(config = {}) {
+        this.config = config;
+    }
+    async ensureClient() {
+        if (this.client)
+            return this.client;
+        const chainId = this.config.chainId || parseInt(process.env.PROBABLE_CHAIN_ID || '56', 10);
+        const wsUrl = this.config.wsUrl || process.env.PROBABLE_WS_URL || 'wss://ws.probable.markets/public/api/v1';
+        const baseUrl = this.config.baseUrl || process.env.PROBABLE_BASE_URL || 'https://api.probable.markets/public/api/v1';
+        // Dynamically import @prob/clob using eval to bypass TS compilation to require()
+        // which forces native import() usage, resolving ESM/CJS issues
+        const { createClobClient: createClient } = await eval('import("@prob/clob")');
+        // For public streams, always provide baseUrl, wsUrl, and chainId
+        this.client = createClient({
+            baseUrl,
+            wsUrl,
+            chainId,
+        });
+        return this.client;
+    }
+    async watchOrderBook(tokenId) {
+        const client = await this.ensureClient();
+        // Subscribe if not already subscribed
+        if (!this.subscriptions.has(tokenId)) {
+            const sub = client.subscribePublicStream([`book:${tokenId}`], (data) => {
+                this.handleOrderBookUpdate(tokenId, data);
+            });
+            this.subscriptions.set(tokenId, sub);
+        }
+        // Return a promise that resolves on the next orderbook update
+        return new Promise((resolve, reject) => {
+            if (!this.orderBookResolvers.has(tokenId)) {
+                this.orderBookResolvers.set(tokenId, []);
+            }
+            this.orderBookResolvers.get(tokenId).push({ resolve, reject });
+        });
+    }
+    handleOrderBookUpdate(tokenId, data) {
+        const bids = (data.bids || []).map((b) => ({
+            price: parseFloat(b.price),
+            size: parseFloat(b.size),
+        })).sort((a, b) => b.price - a.price);
+        const asks = (data.asks || []).map((a) => ({
+            price: parseFloat(a.price),
+            size: parseFloat(a.size),
+        })).sort((a, b) => a.price - b.price);
+        let timestamp = Date.now();
+        if (data.timestamp) {
+            const parsed = typeof data.timestamp === 'number' ? data.timestamp : new Date(data.timestamp).getTime();
+            if (!isNaN(parsed)) {
+                timestamp = parsed;
+                if (timestamp < 10000000000) {
+                    timestamp *= 1000;
+                }
+            }
+        }
+        const orderBook = { bids, asks, timestamp };
+        this.orderBooks.set(tokenId, orderBook);
+        this.resolveOrderBook(tokenId, orderBook);
+    }
+    resolveOrderBook(tokenId, orderBook) {
+        const resolvers = this.orderBookResolvers.get(tokenId);
+        if (resolvers && resolvers.length > 0) {
+            resolvers.forEach(r => r.resolve(orderBook));
+            this.orderBookResolvers.set(tokenId, []);
+        }
+    }
+    async close() {
+        // Unsubscribe from all streams
+        for (const [tokenId, sub] of this.subscriptions) {
+            try {
+                sub.unsubscribe();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        this.subscriptions.clear();
+        // Reject all pending resolvers
+        this.orderBookResolvers.forEach((resolvers, tokenId) => {
+            resolvers.forEach(r => r.reject(new Error(`WebSocket closed for ${tokenId}`)));
+        });
+        this.orderBookResolvers.clear();
+        this.orderBooks.clear();
+        this.client = undefined;
+    }
+}
+exports.ProbableWebSocket = ProbableWebSocket;

package/dist/index.d.ts

@@ -5,18 +5,22 @@ export * from './errors';
 export * from './exchanges/polymarket';
 export * from './exchanges/limitless';
 export * from './exchanges/kalshi';
+export * from './exchanges/probable';
 export * from './server/app';
 export * from './server/utils/port-manager';
 export * from './server/utils/lock-file';
 import { PolymarketExchange } from './exchanges/polymarket';
 import { LimitlessExchange } from './exchanges/limitless';
 import { KalshiExchange } from './exchanges/kalshi';
+import { ProbableExchange } from './exchanges/probable';
 declare const pmxt: {
     Polymarket: typeof PolymarketExchange;
     Limitless: typeof LimitlessExchange;
     Kalshi: typeof KalshiExchange;
+    Probable: typeof ProbableExchange;
 };
 export declare const Polymarket: typeof PolymarketExchange;
 export declare const Limitless: typeof LimitlessExchange;
 export declare const Kalshi: typeof KalshiExchange;
+export declare const Probable: typeof ProbableExchange;
 export default pmxt;

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Kalshi = exports.Limitless = exports.Polymarket = void 0;
+exports.Probable = exports.Kalshi = exports.Limitless = exports.Polymarket = void 0;
 __exportStar(require("./BaseExchange"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/math"), exports);
@@ -22,18 +22,22 @@ __exportStar(require("./errors"), exports);
 __exportStar(require("./exchanges/polymarket"), exports);
 __exportStar(require("./exchanges/limitless"), exports);
 __exportStar(require("./exchanges/kalshi"), exports);
+__exportStar(require("./exchanges/probable"), exports);
 __exportStar(require("./server/app"), exports);
 __exportStar(require("./server/utils/port-manager"), exports);
 __exportStar(require("./server/utils/lock-file"), exports);
 const polymarket_1 = require("./exchanges/polymarket");
 const limitless_1 = require("./exchanges/limitless");
 const kalshi_1 = require("./exchanges/kalshi");
+const probable_1 = require("./exchanges/probable");
 const pmxt = {
     Polymarket: polymarket_1.PolymarketExchange,
     Limitless: limitless_1.LimitlessExchange,
-    Kalshi: kalshi_1.KalshiExchange
+    Kalshi: kalshi_1.KalshiExchange,
+    Probable: probable_1.ProbableExchange
 };
 exports.Polymarket = polymarket_1.PolymarketExchange;
 exports.Limitless = limitless_1.LimitlessExchange;
 exports.Kalshi = kalshi_1.KalshiExchange;
+exports.Probable = probable_1.ProbableExchange;
 exports.default = pmxt;

package/dist/server/app.js

@@ -9,12 +9,14 @@ const cors_1 = __importDefault(require("cors"));
 const polymarket_1 = require("../exchanges/polymarket");
 const limitless_1 = require("../exchanges/limitless");
 const kalshi_1 = require("../exchanges/kalshi");
+const probable_1 = require("../exchanges/probable");
 const errors_1 = require("../errors");
 // Singleton instances for local usage (when no credentials provided)
 const defaultExchanges = {
     polymarket: null,
     limitless: null,
-    kalshi: null
+    kalshi: null,
+    probable: null
 };
 async function startServer(port, accessToken) {
     const app = (0, express_1.default)();
@@ -132,6 +134,13 @@ function createExchange(name, credentials) {
                 apiKey: credentials?.apiKey || process.env.KALSHI_API_KEY,
                 privateKey: credentials?.privateKey || process.env.KALSHI_PRIVATE_KEY
             });
+        case 'probable':
+            return new probable_1.ProbableExchange({
+                apiKey: credentials?.apiKey || process.env.PROBABLE_API_KEY,
+                apiSecret: credentials?.apiSecret || process.env.PROBABLE_API_SECRET,
+                passphrase: credentials?.passphrase || process.env.PROBABLE_PASSPHRASE,
+                privateKey: credentials?.privateKey || process.env.PROBABLE_PRIVATE_KEY,
+            });
         default:
             throw new Error(`Unknown exchange: ${name}`);
     }

package/dist/server/utils/lock-file.js

@@ -38,6 +38,7 @@ const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 class LockFile {
+    lockPath;
     constructor() {
         this.lockPath = path.join(os.homedir(), '.pmxt', 'server.lock');
     }

package/dist/utils/error-mapper.js

@@ -13,6 +13,7 @@ const errors_1 = require("../errors");
  * Can be extended by exchange-specific error mappers for custom error patterns.
  */
 class ErrorMapper {
+    exchangeName;
     constructor(exchangeName) {
         this.exchangeName = exchangeName;
     }