pmxt-core 2.3.0 → 2.4.0

package/dist/BaseExchange.js

@@ -6,6 +6,7 @@ const math_1 = require("./utils/math");
 // Base Exchange Class
 // ----------------------------------------------------------------------------
 class PredictionMarketExchange {
+    credentials;
     constructor(credentials) {
         this.credentials = credentials;
     }

package/dist/errors.js

@@ -8,6 +8,14 @@ exports.ExchangeNotAvailable = exports.NetworkError = exports.ValidationError =
  * across exchanges with HTTP status codes and retry semantics.
  */
 class BaseError extends Error {
+    /** HTTP status code */
+    status;
+    /** Machine-readable error code */
+    code;
+    /** Whether the operation can be retried */
+    retryable;
+    /** Which exchange threw the error */
+    exchange;
     constructor(message, status, code, retryable = false, exchange) {
         super(message);
         this.name = this.constructor.name;
@@ -83,6 +91,8 @@ exports.MarketNotFound = MarketNotFound;
  * 429 Too Many Requests - Rate limit exceeded
  */
 class RateLimitExceeded extends BaseError {
+    /** Number of seconds to wait before retrying */
+    retryAfter;
     constructor(message, retryAfter, exchange) {
         super(message, 429, 'RATE_LIMIT_EXCEEDED', true, exchange);
         this.retryAfter = retryAfter;
@@ -111,6 +121,7 @@ exports.InsufficientFunds = InsufficientFunds;
  * 400 Bad Request - Input validation failed
  */
 class ValidationError extends BaseError {
+    field;
     constructor(message, field, exchange) {
         super(message, 400, 'VALIDATION_ERROR', false, exchange);
         this.field = field;

package/dist/exchanges/kalshi/auth.js

@@ -41,6 +41,7 @@ const errors_1 = require("./errors");
  * Reference: https://docs.kalshi.com/getting_started/quick_start_authenticated_requests
  */
 class KalshiAuth {
+    credentials;
     constructor(credentials) {
         this.credentials = credentials;
         this.validateCredentials();

package/dist/exchanges/kalshi/index.js

@@ -16,6 +16,8 @@ const websocket_1 = require("./websocket");
 const errors_1 = require("./errors");
 const errors_2 = require("../../errors");
 class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
+    auth;
+    wsConfig;
     constructor(options) {
         // Support both old signature (credentials only) and new signature (options object)
         let credentials;
@@ -283,6 +285,10 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
                 return 'open';
         }
     }
+    // ----------------------------------------------------------------------------
+    // WebSocket Methods
+    // ----------------------------------------------------------------------------
+    ws;
     async watchOrderBook(id, limit) {
         const auth = this.ensureAuth();
         if (!this.ws) {

package/dist/exchanges/kalshi/websocket.js

@@ -10,16 +10,21 @@ const ws_1 = __importDefault(require("ws"));
  * Follows CCXT Pro-style async iterator pattern.
  */
 class KalshiWebSocket {
+    ws;
+    auth;
+    config;
+    orderBookResolvers = new Map();
+    tradeResolvers = new Map();
+    orderBooks = new Map();
+    subscribedOrderBookTickers = new Set();
+    subscribedTradeTickers = new Set();
+    messageIdCounter = 1;
+    isConnecting = false;
+    isConnected = false;
+    reconnectTimer;
+    connectionPromise;
+    isTerminated = false;
     constructor(auth, config = {}) {
-        this.orderBookResolvers = new Map();
-        this.tradeResolvers = new Map();
-        this.orderBooks = new Map();
-        this.subscribedOrderBookTickers = new Set();
-        this.subscribedTradeTickers = new Set();
-        this.messageIdCounter = 1;
-        this.isConnecting = false;
-        this.isConnected = false;
-        this.isTerminated = false;
         this.auth = auth;
         this.config = {
             wsUrl: config.wsUrl || 'wss://api.elections.kalshi.com/trade-api/ws/v2',

package/dist/exchanges/limitless/auth.js

@@ -9,6 +9,10 @@ const LIMITLESS_HOST = 'https://api.limitless.exchange';
  * Simplified from cookie-based to API key authentication.
  */
 class LimitlessAuth {
+    credentials;
+    signer;
+    httpClient;
+    apiKey;
     constructor(credentials) {
         this.credentials = credentials;
         // API key is required for authenticated endpoints

package/dist/exchanges/limitless/client.js

@@ -9,8 +9,12 @@ const LIMITLESS_API_URL = 'https://api.limitless.exchange';
  * Provides a simplified interface for market data and order operations.
  */
 class LimitlessClient {
+    httpClient;
+    orderClient;
+    marketFetcher;
+    signer;
+    marketCache = {};
     constructor(privateKey, apiKey) {
-        this.marketCache = {};
         // Fix for common .env issue where newlines are escaped
         if (privateKey.includes('\\n')) {
             privateKey = privateKey.replace(/\\n/g, '\n');

package/dist/exchanges/limitless/index.js

@@ -16,6 +16,9 @@ const errors_2 = require("../../errors");
 const sdk_1 = require("@limitless-exchange/sdk");
 const ethers_1 = require("ethers");
 class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
+    auth;
+    client;
+    wsConfig;
     constructor(options) {
         // Support both old signature (credentials only) and new signature (options object)
         let credentials;
@@ -112,7 +115,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
                 throw new Error('Limit orders require a price');
             }
             // Limitless (USDC on Base) supports 6 decimals max.
-            const price = Math.round(params.price * 1000000) / 1000000;
+            const price = Math.round(params.price * 1_000_000) / 1_000_000;
             const response = await client.createOrder({
                 marketSlug: marketSlug,
                 outcomeId: params.outcomeId,
@@ -231,6 +234,10 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             throw errors_1.limitlessErrorMapper.mapError(error);
         }
     }
+    // ----------------------------------------------------------------------------
+    // WebSocket Methods
+    // ----------------------------------------------------------------------------
+    ws;
     /**
      * Initialize WebSocket with API key if available.
      */

package/dist/exchanges/limitless/websocket.js

@@ -21,12 +21,14 @@ function convertSize(rawSize) {
  * - User transactions (requires API key)
  */
 class LimitlessWebSocket {
+    client;
+    config;
+    orderbookCallbacks = new Map();
+    priceCallbacks = new Map();
+    orderbookResolvers = new Map();
+    orderbookBuffers = new Map();
+    lastOrderbookTimestamps = new Map();
     constructor(config = {}) {
-        this.orderbookCallbacks = new Map();
-        this.priceCallbacks = new Map();
-        this.orderbookResolvers = new Map();
-        this.orderbookBuffers = new Map();
-        this.lastOrderbookTimestamps = new Map();
         this.config = config;
         // Initialize SDK WebSocket client
         const wsConfig = {

package/dist/exchanges/polymarket/auth.js

@@ -15,6 +15,12 @@ const POLYGON_CHAIN_ID = 137;
  * Handles both L1 (wallet-based) and L2 (API credentials) authentication.
  */
 class PolymarketAuth {
+    credentials;
+    signer;
+    clobClient;
+    apiCreds;
+    discoveredProxyAddress;
+    discoveredSignatureType;
     constructor(credentials) {
         this.credentials = credentials;
         if (!credentials.privateKey) {

package/dist/exchanges/polymarket/index.js

@@ -14,6 +14,8 @@ const websocket_1 = require("./websocket");
 const errors_1 = require("./errors");
 const errors_2 = require("../../errors");
 class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
+    auth;
+    wsConfig;
     constructor(options) {
         // Support both old signature (credentials only) and new signature (options object)
         let credentials;
@@ -293,6 +295,10 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             throw errors_1.polymarketErrorMapper.mapError(error);
         }
     }
+    // ----------------------------------------------------------------------------
+    // WebSocket Methods
+    // ----------------------------------------------------------------------------
+    ws;
     async watchOrderBook(id, limit) {
         if (!this.ws) {
             this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);

package/dist/exchanges/polymarket/websocket.js

@@ -46,10 +46,13 @@ exports.PolymarketWebSocket = void 0;
  * watchOrderBook() and watchTrades() methods.
  */
 class PolymarketWebSocket {
+    manager;
+    orderBookResolvers = new Map();
+    tradeResolvers = new Map();
+    orderBooks = new Map();
+    config;
+    initializationPromise;
     constructor(config = {}) {
-        this.orderBookResolvers = new Map();
-        this.tradeResolvers = new Map();
-        this.orderBooks = new Map();
         this.config = config;
     }
     async ensureInitialized() {

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

@@ -0,0 +1,14 @@
+import { createClobClient } from '@prob/clob';
+import { ExchangeCredentials } from '../../BaseExchange';
+/**
+ * Manages Probable authentication and CLOB client initialization.
+ * Requires a privateKey and pre-generated API key triplet (apiKey, apiSecret, passphrase).
+ */
+export declare class ProbableAuth {
+    private credentials;
+    private clobClient?;
+    private walletAddress;
+    constructor(credentials: ExchangeCredentials);
+    getClobClient(): ReturnType<typeof createClobClient>;
+    getAddress(): string;
+}

package/dist/exchanges/probable/auth.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProbableAuth = void 0;
+const clob_1 = require("@prob/clob");
+const accounts_1 = require("viem/accounts");
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+/**
+ * Manages Probable authentication and CLOB client initialization.
+ * Requires a privateKey and pre-generated API key triplet (apiKey, apiSecret, passphrase).
+ */
+class ProbableAuth {
+    credentials;
+    clobClient;
+    walletAddress;
+    constructor(credentials) {
+        this.credentials = credentials;
+        if (!credentials.privateKey) {
+            throw new Error('Probable requires a privateKey for authentication');
+        }
+        if (!credentials.apiKey || !credentials.apiSecret || !credentials.passphrase) {
+            throw new Error('Probable requires pre-generated API credentials (apiKey, apiSecret, passphrase). ' +
+                'Generate them at https://probable.markets or via the SDK.');
+        }
+        const account = (0, accounts_1.privateKeyToAccount)(credentials.privateKey);
+        this.walletAddress = account.address;
+    }
+    getClobClient() {
+        if (this.clobClient) {
+            return this.clobClient;
+        }
+        const chainId = parseInt(process.env.PROBABLE_CHAIN_ID || '56', 10);
+        const chain = chainId === 97 ? chains_1.bscTestnet : chains_1.bsc;
+        const account = (0, accounts_1.privateKeyToAccount)(this.credentials.privateKey);
+        const wallet = (0, viem_1.createWalletClient)({
+            account,
+            chain,
+            transport: (0, viem_1.http)(),
+        });
+        const credential = {
+            key: this.credentials.apiKey,
+            secret: this.credentials.apiSecret,
+            passphrase: this.credentials.passphrase,
+        };
+        if (chainId === 56) {
+            this.clobClient = (0, clob_1.createClobClient)({
+                chainId: 56,
+                wallet,
+                credential,
+            });
+        }
+        else {
+            const baseUrl = process.env.PROBABLE_BASE_URL || 'https://api.probable.markets/public/api/v1';
+            this.clobClient = (0, clob_1.createClobClient)({
+                chainId,
+                baseUrl,
+                wallet,
+                credential,
+            });
+        }
+        return this.clobClient;
+    }
+    getAddress() {
+        return this.walletAddress;
+    }
+}
+exports.ProbableAuth = ProbableAuth;

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

@@ -0,0 +1,8 @@
+import { ErrorMapper } from '../../utils/error-mapper';
+import { BadRequest } from '../../errors';
+export declare class ProbableErrorMapper extends ErrorMapper {
+    constructor();
+    protected extractErrorMessage(error: any): string;
+    protected mapBadRequestError(message: string, data: any): BadRequest;
+}
+export declare const probableErrorMapper: ProbableErrorMapper;

package/dist/exchanges/probable/errors.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probableErrorMapper = exports.ProbableErrorMapper = void 0;
+const axios_1 = __importDefault(require("axios"));
+const error_mapper_1 = require("../../utils/error-mapper");
+const errors_1 = require("../../errors");
+class ProbableErrorMapper extends error_mapper_1.ErrorMapper {
+    constructor() {
+        super('Probable');
+    }
+    extractErrorMessage(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.data) {
+            const data = error.response.data;
+            if (data.detail) {
+                return typeof data.detail === 'string' ? data.detail : JSON.stringify(data.detail);
+            }
+            if (data.message) {
+                return String(data.message);
+            }
+            if (data.error) {
+                return typeof data.error === 'string' ? data.error : JSON.stringify(data.error);
+            }
+        }
+        // Handle @prob/clob SDK error objects
+        if (error && typeof error === 'object' && error.msg) {
+            return String(error.msg);
+        }
+        return super.extractErrorMessage(error);
+    }
+    mapBadRequestError(message, data) {
+        const lowerMessage = message.toLowerCase();
+        // SDK auth failures
+        if (lowerMessage.includes('l1 auth') ||
+            lowerMessage.includes('l2 auth') ||
+            lowerMessage.includes('invalid api key') ||
+            lowerMessage.includes('invalid signature') ||
+            lowerMessage.includes('api key')) {
+            return new errors_1.AuthenticationError(message, this.exchangeName);
+        }
+        // Insufficient funds
+        if (lowerMessage.includes('insufficient') ||
+            lowerMessage.includes('balance') ||
+            lowerMessage.includes('not enough')) {
+            return new errors_1.InsufficientFunds(message, this.exchangeName);
+        }
+        // Invalid order params
+        if (lowerMessage.includes('invalid order') ||
+            lowerMessage.includes('tick size') ||
+            lowerMessage.includes('price must') ||
+            lowerMessage.includes('size must') ||
+            lowerMessage.includes('amount must')) {
+            return new errors_1.InvalidOrder(message, this.exchangeName);
+        }
+        return super.mapBadRequestError(message, data);
+    }
+}
+exports.ProbableErrorMapper = ProbableErrorMapper;
+exports.probableErrorMapper = new ProbableErrorMapper();

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

@@ -0,0 +1,5 @@
+import { EventFetchParams } from '../../BaseExchange';
+import { UnifiedEvent } from '../../types';
+export declare function fetchEvents(params: EventFetchParams): Promise<UnifiedEvent[]>;
+export declare function fetchEventById(id: string): Promise<UnifiedEvent | null>;
+export declare function fetchEventBySlug(slug: string): Promise<UnifiedEvent | null>;

package/dist/exchanges/probable/fetchEvents.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchEvents = fetchEvents;
+exports.fetchEventById = fetchEventById;
+exports.fetchEventBySlug = fetchEventBySlug;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+async function fetchEvents(params) {
+    try {
+        // Query-based search: use the search endpoint (only endpoint with text search)
+        if (params.query) {
+            return await searchEvents(params);
+        }
+        // Default: use the dedicated events API for listing
+        return await fetchEventsList(params);
+    }
+    catch (error) {
+        throw errors_1.probableErrorMapper.mapError(error);
+    }
+}
+async function fetchEventById(id) {
+    try {
+        const numericId = Number(id);
+        if (isNaN(numericId))
+            return null;
+        const response = await axios_1.default.get(`${utils_1.BASE_URL}${utils_1.EVENTS_PATH}${numericId}`);
+        const event = (0, utils_1.mapEventToUnified)(response.data);
+        if (event)
+            await (0, utils_1.enrichMarketsWithPrices)(event.markets);
+        return event;
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw errors_1.probableErrorMapper.mapError(error);
+    }
+}
+async function fetchEventBySlug(slug) {
+    try {
+        const response = await axios_1.default.get(`${utils_1.BASE_URL}${utils_1.EVENTS_PATH}slug/${slug}`);
+        const event = (0, utils_1.mapEventToUnified)(response.data);
+        if (event)
+            await (0, utils_1.enrichMarketsWithPrices)(event.markets);
+        return event;
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw errors_1.probableErrorMapper.mapError(error);
+    }
+}
+async function fetchEventsList(params) {
+    const limit = params.limit || 20;
+    const page = params.offset ? Math.floor(params.offset / limit) + 1 : 1;
+    const queryParams = {
+        page,
+        limit,
+    };
+    // Map status
+    if (params.status) {
+        switch (params.status) {
+            case 'active':
+                queryParams.status = 'active';
+                break;
+            case 'inactive':
+            case 'closed':
+                queryParams.status = 'closed';
+                break;
+            case 'all':
+                queryParams.status = 'all';
+                break;
+        }
+    }
+    else {
+        queryParams.status = 'active';
+    }
+    // Default sort by volume
+    queryParams.sort = 'volume';
+    queryParams.ascending = false;
+    const response = await axios_1.default.get(`${utils_1.BASE_URL}${utils_1.EVENTS_PATH}`, {
+        params: queryParams,
+    });
+    const events = response.data?.events || [];
+    const result = events
+        .map((event) => (0, utils_1.mapEventToUnified)(event))
+        .filter((e) => e !== null);
+    const allMarkets = result.flatMap((e) => e.markets);
+    await (0, utils_1.enrichMarketsWithPrices)(allMarkets);
+    return result;
+}
+async function searchEvents(params) {
+    const limit = params.limit || 20;
+    const page = params.offset ? Math.floor(params.offset / limit) + 1 : 1;
+    const response = await axios_1.default.get(`${utils_1.BASE_URL}${utils_1.SEARCH_PATH}`, {
+        params: {
+            q: params.query,
+            page,
+            limit,
+            events_status: mapStatus(params.status),
+            keep_closed_markets: params.status === 'all' || params.status === 'inactive' || params.status === 'closed' ? 1 : 0,
+        },
+    });
+    const events = response.data?.events || [];
+    const result = events
+        .map((event) => (0, utils_1.mapEventToUnified)(event))
+        .filter((e) => e !== null);
+    const allMarkets = result.flatMap((e) => e.markets);
+    await (0, utils_1.enrichMarketsWithPrices)(allMarkets);
+    return result;
+}
+function isNotFoundError(error) {
+    const status = error.response?.status;
+    if (status === 404 || status === 400)
+        return true;
+    // API returns 500 with plain-text "not found" message for missing resources
+    if (status === 500) {
+        const data = error.response?.data;
+        const msg = typeof data === 'string' ? data : (data?.detail || data?.message || '');
+        return /not found/i.test(String(msg));
+    }
+    return false;
+}
+function mapStatus(status) {
+    switch (status) {
+        case 'inactive':
+        case 'closed':
+            return 'closed';
+        case 'all':
+            return 'all';
+        case 'active':
+        default:
+            return 'active';
+    }
+}

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

@@ -0,0 +1,3 @@
+import { MarketFetchParams } from '../../BaseExchange';
+import { UnifiedMarket } from '../../types';
+export declare function fetchMarkets(params?: MarketFetchParams): Promise<UnifiedMarket[]>;