pmxt-core 2.2.0 → 2.4.0

package/dist/exchanges/probable/fetchMarkets.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchMarkets = fetchMarkets;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+async function fetchMarkets(params) {
+    try {
+        // Slug-based lookup: try market ID or slug via dedicated endpoint
+        if (params?.slug) {
+            return await fetchMarketByIdOrSlug(params.slug);
+        }
+        // Query-based search: use the search endpoint (only endpoint with text search)
+        if (params?.query) {
+            return await searchAndExtractMarkets(params.query, params);
+        }
+        // Default: use the dedicated markets API for listing
+        return await fetchMarketsList(params);
+    }
+    catch (error) {
+        throw errors_1.probableErrorMapper.mapError(error);
+    }
+}
+async function fetchMarketByIdOrSlug(slug) {
+    let cleanSlug = slug;
+    let marketIdFromQuery = null;
+    // Handle URLs or partial URLs with query params (e.g., opinion-...-launch?market=584)
+    if (slug.includes('?')) {
+        try {
+            const urlParts = slug.split('?');
+            cleanSlug = urlParts[0];
+            const query = urlParts[1];
+            const params = new URLSearchParams(query);
+            marketIdFromQuery = params.get('market');
+            // If we have a market ID from the query, try that first
+            if (marketIdFromQuery) {
+                const result = await fetchMarketByIdOrSlug(marketIdFromQuery);
+                if (result.length > 0)
+                    return result;
+            }
+        }
+        catch (e) {
+            // Fall back to original slug if parsing fails
+        }
+    }
+    // Try numeric ID lookup first
+    const numericId = Number(cleanSlug);
+    if (!isNaN(numericId) && String(numericId) === cleanSlug) {
+        try {
+            const response = await axios_1.default.get(`${utils_1.BASE_URL}${utils_1.MARKETS_PATH}${numericId}`);
+            const mapped = (0, utils_1.mapMarketToUnified)(response.data, response.data?.event);
+            const results = mapped ? [mapped] : [];
+            await (0, utils_1.enrichMarketsWithPrices)(results);
+            return results;
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    // Fall back to search for slug-based matching
+    return await searchAndExtractMarkets(cleanSlug, { slug: cleanSlug });
+}
+async function fetchMarketsList(params) {
+    const limit = params?.limit || 20;
+    const page = params?.offset ? Math.floor(params.offset / limit) + 1 : 1;
+    const queryParams = {
+        page,
+        limit,
+    };
+    // Map status filters
+    if (params?.status) {
+        switch (params.status) {
+            case 'active':
+                queryParams.active = true;
+                break;
+            case 'inactive':
+            case 'closed':
+                queryParams.closed = true;
+                break;
+            case 'all':
+                // No filter
+                break;
+        }
+    }
+    else {
+        queryParams.active = true;
+    }
+    // Map event_id if provided
+    if (params?.eventId) {
+        queryParams.event_id = params.eventId;
+    }
+    const response = await axios_1.default.get(`${utils_1.BASE_URL}${utils_1.MARKETS_PATH}`, {
+        params: queryParams,
+    });
+    const markets = response.data?.markets || [];
+    const allMarkets = [];
+    for (const market of markets) {
+        const mapped = (0, utils_1.mapMarketToUnified)(market, market.event);
+        if (mapped)
+            allMarkets.push(mapped);
+    }
+    await (0, utils_1.enrichMarketsWithPrices)(allMarkets);
+    return allMarkets;
+}
+async function searchAndExtractMarkets(query, params) {
+    const limit = params?.limit || 20;
+    const page = params?.offset ? Math.floor(params.offset / limit) + 1 : 1;
+    // Improve search for slugs: if the query looks like a slug (has dashes), 
+    // try searching with the first few words as keywords.
+    // The Probable search engine often fails with long, exact slug-like queries.
+    let searchQuery = query;
+    if (query.includes('-')) {
+        const tokens = query.split('-');
+        // Use first 3 tokens for search to cast a wider but relevant net
+        searchQuery = tokens.slice(0, 3).join(' ');
+    }
+    const queryParams = {
+        q: searchQuery,
+        page,
+        limit,
+    };
+    // Map status
+    if (params?.status) {
+        switch (params.status) {
+            case 'inactive':
+            case 'closed':
+                queryParams.events_status = 'closed';
+                queryParams.keep_closed_markets = 1;
+                break;
+            case 'all':
+                queryParams.events_status = 'all';
+                queryParams.keep_closed_markets = 1;
+                break;
+            case 'active':
+            default:
+                queryParams.events_status = 'active';
+                queryParams.keep_closed_markets = 0;
+                break;
+        }
+    }
+    else if (params?.slug) {
+        // For slug lookups, default to 'all' status to be safe
+        queryParams.events_status = 'all';
+        queryParams.keep_closed_markets = 1;
+    }
+    else {
+        queryParams.events_status = 'active';
+        queryParams.keep_closed_markets = 0;
+    }
+    // Map sort
+    if (params?.sort) {
+        switch (params.sort) {
+            case 'volume':
+                queryParams.sort = 'volume';
+                break;
+            case 'newest':
+                queryParams.sort = 'created_at';
+                queryParams.ascending = false;
+                break;
+        }
+    }
+    const response = await axios_1.default.get(`${utils_1.BASE_URL}${utils_1.SEARCH_PATH}`, {
+        params: queryParams,
+    });
+    const events = response.data?.events || [];
+    const allMarkets = [];
+    for (const event of events) {
+        if (event.markets && Array.isArray(event.markets)) {
+            for (const market of event.markets) {
+                const mapped = (0, utils_1.mapMarketToUnified)(market, event);
+                if (mapped) {
+                    // Inject a temporary field for slug matching
+                    mapped._eventSlug = event.slug;
+                    allMarkets.push(mapped);
+                }
+            }
+        }
+    }
+    // If slug lookup, try to find exact match
+    if (params?.slug) {
+        const exact = allMarkets.filter(m => m.marketId === params.slug ||
+            m.url.includes(params.slug) ||
+            m._eventSlug === params.slug);
+        // Remove temporary fields before returning
+        for (const m of exact) {
+            delete m._eventSlug;
+        }
+        if (exact.length > 0) {
+            await (0, utils_1.enrichMarketsWithPrices)(exact);
+            return exact;
+        }
+    }
+    // Clean up temporary fields for all markets if no exact match found
+    for (const m of allMarkets) {
+        delete m._eventSlug;
+    }
+    await (0, utils_1.enrichMarketsWithPrices)(allMarkets);
+    return allMarkets;
+}

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

@@ -0,0 +1,3 @@
+import { OHLCVParams, HistoryFilterParams } from '../../BaseExchange';
+import { PriceCandle } from '../../types';
+export declare function fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;

package/dist/exchanges/probable/fetchOHLCV.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOHLCV = fetchOHLCV;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+const INTERVAL_MAP = {
+    '1m': '1m',
+    '5m': '1m',
+    '15m': '1m',
+    '1h': '1h',
+    '6h': '6h',
+    '1d': '1d',
+};
+function aggregateCandles(candles, intervalMs) {
+    if (candles.length === 0)
+        return [];
+    const buckets = new Map();
+    for (const c of candles) {
+        const key = Math.floor(c.timestamp / intervalMs) * intervalMs;
+        const existing = buckets.get(key);
+        if (!existing) {
+            buckets.set(key, { ...c, timestamp: key });
+        }
+        else {
+            existing.high = Math.max(existing.high, c.high);
+            existing.low = Math.min(existing.low, c.low);
+            existing.close = c.close;
+        }
+    }
+    return Array.from(buckets.values()).sort((a, b) => a.timestamp - b.timestamp);
+}
+async function fetchOHLCV(id, params) {
+    if (!params.resolution) {
+        throw new Error('fetchOHLCV requires a resolution parameter.');
+    }
+    try {
+        const apiInterval = INTERVAL_MAP[params.resolution] || '1h';
+        const queryParams = {
+            market: id,
+            interval: apiInterval,
+        };
+        if (params.start)
+            queryParams.startTs = Math.floor(params.start.getTime() / 1000);
+        if (params.end)
+            queryParams.endTs = Math.floor(params.end.getTime() / 1000);
+        const response = await axios_1.default.get(`${utils_1.CLOB_BASE_URL}/prices-history`, {
+            params: queryParams,
+        });
+        const points = response.data?.history || response.data || [];
+        let candles = points
+            .map((p) => {
+            const price = Number(p.p);
+            const ts = Number(p.t) * 1000;
+            return {
+                timestamp: ts,
+                open: price,
+                high: price,
+                low: price,
+                close: price,
+                volume: 0,
+            };
+        })
+            .sort((a, b) => a.timestamp - b.timestamp);
+        // Client-side aggregation for intervals that don't have a direct API mapping
+        if (params.resolution === '5m') {
+            candles = aggregateCandles(candles, 5 * 60 * 1000);
+        }
+        else if (params.resolution === '15m') {
+            candles = aggregateCandles(candles, 15 * 60 * 1000);
+        }
+        if (params.limit) {
+            candles = candles.slice(-params.limit);
+        }
+        return candles;
+    }
+    catch (error) {
+        throw errors_1.probableErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,2 @@
+import { OrderBook } from '../../types';
+export declare function fetchOrderBook(id: string): Promise<OrderBook>;

package/dist/exchanges/probable/fetchOrderBook.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOrderBook = fetchOrderBook;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+async function fetchOrderBook(id) {
+    try {
+        const response = await axios_1.default.get(`${utils_1.CLOB_BASE_URL}/book`, {
+            params: { token_id: id },
+        });
+        const data = response.data;
+        const bids = (data.bids || [])
+            .map((level) => ({
+            price: parseFloat(level.price),
+            size: parseFloat(level.size),
+        }))
+            .sort((a, b) => b.price - a.price);
+        const asks = (data.asks || [])
+            .map((level) => ({
+            price: parseFloat(level.price),
+            size: parseFloat(level.size),
+        }))
+            .sort((a, b) => a.price - b.price);
+        return {
+            bids,
+            asks,
+            timestamp: data.timestamp ? new Date(data.timestamp).getTime() : Date.now(),
+        };
+    }
+    catch (error) {
+        throw errors_1.probableErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,2 @@
+import { Position } from '../../types';
+export declare function fetchPositions(userAddress: string): Promise<Position[]>;

package/dist/exchanges/probable/fetchPositions.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPositions = fetchPositions;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("./errors");
+const POSITIONS_URL = 'https://api.probable.markets/public/api/v1/position/current';
+async function fetchPositions(userAddress) {
+    try {
+        const response = await axios_1.default.get(POSITIONS_URL, {
+            params: {
+                user: userAddress,
+                limit: 500,
+            },
+        });
+        const data = Array.isArray(response.data) ? response.data : (response.data?.data || []);
+        return data.map((p) => ({
+            marketId: String(p.conditionId || p.condition_id || ''),
+            outcomeId: String(p.asset || p.token_id || ''),
+            outcomeLabel: p.outcome || p.title || 'Unknown',
+            size: parseFloat(p.size || '0'),
+            entryPrice: parseFloat(p.avgPrice || p.avg_price || '0'),
+            currentPrice: parseFloat(p.curPrice || p.cur_price || '0'),
+            unrealizedPnL: parseFloat(p.cashPnl || p.cash_pnl || '0'),
+            realizedPnL: parseFloat(p.realizedPnl || p.realized_pnl || '0'),
+        }));
+    }
+    catch (error) {
+        throw errors_1.probableErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { createClobClient } from '@prob/clob';
+import { TradesParams, HistoryFilterParams } from '../../BaseExchange';
+import { Trade } from '../../types';
+/**
+ * Fetch trade history for a specific token using the @prob/clob SDK.
+ * @param id - The token ID (outcomeId)
+ * @param params - Trade query parameters
+ * @param client - Authenticated ClobClient instance
+ */
+export declare function fetchTrades(id: string, params: TradesParams | HistoryFilterParams, client: ReturnType<typeof createClobClient>): Promise<Trade[]>;

package/dist/exchanges/probable/fetchTrades.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTrades = fetchTrades;
+const errors_1 = require("./errors");
+/**
+ * Fetch trade history for a specific token using the @prob/clob SDK.
+ * @param id - The token ID (outcomeId)
+ * @param params - Trade query parameters
+ * @param client - Authenticated ClobClient instance
+ */
+async function fetchTrades(id, params, client) {
+    try {
+        const queryParams = {
+            tokenId: id,
+        };
+        if (params.limit) {
+            queryParams.limit = params.limit;
+        }
+        const response = await client.getTrades(queryParams);
+        const trades = Array.isArray(response) ? response : response?.data || [];
+        return trades.map((trade) => ({
+            id: String(trade.id || trade.tradeId || `${trade.time}-${trade.price}`),
+            timestamp: typeof trade.time === 'number'
+                ? (trade.time < 1e12 ? trade.time * 1000 : trade.time)
+                : Date.now(),
+            price: parseFloat(String(trade.price || '0')),
+            amount: parseFloat(String(trade.qty || trade.size || trade.amount || '0')),
+            side: trade.side === 'BUY' ? 'buy'
+                : trade.side === 'SELL' ? 'sell'
+                    : 'unknown',
+        }));
+    }
+    catch (error) {
+        throw errors_1.probableErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,35 @@
+import { PredictionMarketExchange, MarketFetchParams, EventFetchParams, ExchangeCredentials, OHLCVParams, HistoryFilterParams, TradesParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, OrderBook, PriceCandle, Trade, Order, Position, Balance, CreateOrderParams } from '../../types';
+import { ProbableWebSocketConfig } from './websocket';
+export declare class ProbableExchange extends PredictionMarketExchange {
+    private auth?;
+    private ws?;
+    private wsConfig?;
+    constructor(credentials?: ExchangeCredentials, wsConfig?: ProbableWebSocketConfig);
+    get name(): string;
+    private ensureAuth;
+    protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    getEventById(id: string): Promise<UnifiedEvent | null>;
+    getEventBySlug(slug: string): Promise<UnifiedEvent | null>;
+    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    /**
+     * Cancel an order.
+     * The Probable SDK requires both orderId and tokenId for cancellation.
+     * Pass a compound key as "orderId:tokenId" to provide both values.
+     */
+    cancelOrder(orderId: string): Promise<Order>;
+    /**
+     * Fetch a single order by ID.
+     * Pass a compound key as "orderId:tokenId" since the SDK requires both.
+     */
+    fetchOrder(orderId: string): Promise<Order>;
+    fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    fetchPositions(): Promise<Position[]>;
+    fetchBalance(): Promise<Balance[]>;
+    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
+    close(): Promise<void>;
+}