pmxt-core 2.20.1 → 2.20.2

package/dist/exchanges/probable/fetcher.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProbableFetcher = void 0;
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+class ProbableFetcher {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    // -----------------------------------------------------------------------
+    // Markets
+    // -----------------------------------------------------------------------
+    async fetchRawMarkets(params) {
+        try {
+            if (params?.marketId) {
+                return this.fetchRawMarketByIdOrSlug(params.marketId);
+            }
+            if (params?.slug) {
+                return this.fetchRawMarketByIdOrSlug(params.slug);
+            }
+            if (params?.outcomeId) {
+                return this.fetchRawMarketsList(params);
+            }
+            if (params?.eventId) {
+                return this.fetchRawMarketsList(params);
+            }
+            if (params?.query) {
+                return this.fetchRawMarketsViaSearch(params.query, params);
+            }
+            return this.fetchRawMarketsList(params);
+        }
+        catch (error) {
+            throw errors_1.probableErrorMapper.mapError(error);
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Events
+    // -----------------------------------------------------------------------
+    async fetchRawEvents(params) {
+        try {
+            if (params.eventId) {
+                const event = await this.fetchRawEventById(params.eventId);
+                return event ? [event] : [];
+            }
+            if (params.slug) {
+                const event = await this.fetchRawEventBySlug(params.slug);
+                return event ? [event] : [];
+            }
+            if (params.query) {
+                return this.fetchRawEventsViaSearch(params);
+            }
+            return this.fetchRawEventsList(params);
+        }
+        catch (error) {
+            throw errors_1.probableErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawEventById(id) {
+        try {
+            const numericId = Number(id);
+            if (isNaN(numericId))
+                return null;
+            const response = await this.ctx.http.get(`${utils_1.BASE_URL}${utils_1.EVENTS_PATH}${numericId}`);
+            return response.data || null;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return null;
+            throw errors_1.probableErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawEventBySlug(slug) {
+        try {
+            const response = await this.ctx.http.get(`${utils_1.BASE_URL}${utils_1.EVENTS_PATH}slug/${slug}`);
+            return response.data || null;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return null;
+            throw errors_1.probableErrorMapper.mapError(error);
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Order Book
+    // -----------------------------------------------------------------------
+    async fetchRawOrderBook(id) {
+        const data = await this.ctx.callApi('getPublicApiV1Book', { token_id: id });
+        return data;
+    }
+    // -----------------------------------------------------------------------
+    // OHLCV
+    // -----------------------------------------------------------------------
+    async fetchRawOHLCV(id, params) {
+        const INTERVAL_MAP = {
+            '1m': '1m',
+            '5m': '1m',
+            '15m': '1m',
+            '1h': '1h',
+            '6h': '6h',
+            '1d': '1d',
+        };
+        const queryParams = {
+            market: id,
+            interval: INTERVAL_MAP[params.resolution] || '1h',
+        };
+        if (params.start)
+            queryParams.startTs = Math.floor(params.start.getTime() / 1000);
+        if (params.end)
+            queryParams.endTs = Math.floor(params.end.getTime() / 1000);
+        const data = await this.ctx.callApi('getPublicApiV1PricesHistory', queryParams);
+        return data?.history || data || [];
+    }
+    // -----------------------------------------------------------------------
+    // Trades
+    // -----------------------------------------------------------------------
+    async fetchRawTrades(id, params) {
+        const queryParams = { tokenId: id };
+        if (params.limit)
+            queryParams.limit = params.limit;
+        // Uses CLOB client via callApi -- the SDK class will pass the CLOB
+        // client's getTrades through callApi or directly. For now, this goes
+        // through the implicit API.
+        const data = await this.ctx.callApi('getPublicApiV1Trades', queryParams);
+        const trades = Array.isArray(data) ? data : (data?.data || []);
+        return trades;
+    }
+    async fetchRawMyTrades(params, walletAddress) {
+        const queryParams = { user: walletAddress };
+        if (params?.limit)
+            queryParams.limit = params.limit;
+        const data = await this.ctx.callApi('getPublicApiV1Trades', queryParams);
+        const trades = Array.isArray(data) ? data : (data?.data || []);
+        return trades;
+    }
+    // -----------------------------------------------------------------------
+    // Positions & Balance
+    // -----------------------------------------------------------------------
+    async fetchRawPositions(walletAddress) {
+        const result = await this.ctx.callApi('getPublicApiV1PositionCurrent', { user: walletAddress, limit: 500 });
+        return Array.isArray(result) ? result : (result?.data || []);
+    }
+    // -----------------------------------------------------------------------
+    // Midpoint (price enrichment)
+    // -----------------------------------------------------------------------
+    async fetchRawMidpoint(tokenId) {
+        return this.ctx.callApi('getPublicApiV1Midpoint', { token_id: tokenId });
+    }
+    async fetchRawSearch(queryParams) {
+        return this.ctx.callApi('getPublicApiV1PublicSearch', queryParams);
+    }
+    // -----------------------------------------------------------------------
+    // Private helpers
+    // -----------------------------------------------------------------------
+    async fetchRawMarketByIdOrSlug(slug) {
+        let cleanSlug = slug;
+        let marketIdFromQuery = null;
+        if (slug.includes('?')) {
+            try {
+                const urlParts = slug.split('?');
+                cleanSlug = urlParts[0];
+                const query = urlParts[1];
+                const searchParams = new URLSearchParams(query);
+                marketIdFromQuery = searchParams.get('market');
+                if (marketIdFromQuery) {
+                    const result = await this.fetchRawMarketByIdOrSlug(marketIdFromQuery);
+                    if (result.length > 0)
+                        return result;
+                }
+            }
+            catch {
+                // Fall back to original slug if parsing fails
+            }
+        }
+        const numericId = Number(cleanSlug);
+        if (!isNaN(numericId) && String(numericId) === cleanSlug) {
+            try {
+                const response = await this.ctx.http.get(`${utils_1.BASE_URL}${utils_1.MARKETS_PATH}${numericId}`);
+                return response.data ? [response.data] : [];
+            }
+            catch (error) {
+                if (isMarketNotFoundError(error)) {
+                    const response = await this.ctx.http.get(`${utils_1.BASE_URL}${utils_1.MARKETS_PATH}`, {
+                        params: { page: 1, limit: 100, active: true },
+                    });
+                    const markets = response.data?.markets || [];
+                    return markets.filter(m => String(m.id) === cleanSlug);
+                }
+                throw error;
+            }
+        }
+        return this.fetchRawMarketsViaSearch(cleanSlug, { slug: cleanSlug });
+    }
+    async fetchRawMarketsList(params) {
+        const limit = params?.limit || 20;
+        const page = params?.offset ? Math.floor(params.offset / limit) + 1 : 1;
+        const queryParams = { page, limit };
+        if (params?.status) {
+            switch (params.status) {
+                case 'active':
+                    queryParams.active = true;
+                    break;
+                case 'inactive':
+                case 'closed':
+                    queryParams.closed = true;
+                    break;
+                case 'all':
+                    break;
+            }
+        }
+        else {
+            queryParams.active = true;
+        }
+        if (params?.eventId) {
+            queryParams.event_id = params.eventId;
+        }
+        const response = await this.ctx.http.get(`${utils_1.BASE_URL}${utils_1.MARKETS_PATH}`, { params: queryParams });
+        return response.data?.markets || [];
+    }
+    async fetchRawMarketsViaSearch(query, params) {
+        const limit = params?.limit || 20;
+        const page = params?.offset ? Math.floor(params.offset / limit) + 1 : 1;
+        let searchQuery = query;
+        if (query.includes('-')) {
+            const tokens = query.split('-');
+            searchQuery = tokens.slice(0, 3).join(' ');
+        }
+        const queryParams = { q: searchQuery, page, limit };
+        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) {
+            queryParams.events_status = 'all';
+            queryParams.keep_closed_markets = 1;
+        }
+        else {
+            queryParams.events_status = 'active';
+            queryParams.keep_closed_markets = 0;
+        }
+        if (params?.sort) {
+            switch (params.sort) {
+                case 'volume':
+                    queryParams.sort = 'volume';
+                    break;
+                case 'newest':
+                    queryParams.sort = 'created_at';
+                    queryParams.ascending = false;
+                    break;
+            }
+        }
+        const searchData = await this.ctx.callApi('getPublicApiV1PublicSearch', queryParams);
+        const events = searchData?.events || [];
+        const rawMarkets = [];
+        for (const event of events) {
+            if (event.markets && Array.isArray(event.markets)) {
+                for (const market of event.markets) {
+                    rawMarkets.push({ ...market, _parentEvent: event });
+                }
+            }
+        }
+        return rawMarkets;
+    }
+    async fetchRawEventsList(params) {
+        const limit = params.limit || 20;
+        const page = params.offset ? Math.floor(params.offset / limit) + 1 : 1;
+        const queryParams = { page, limit };
+        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';
+        }
+        queryParams.sort = 'volume';
+        queryParams.ascending = false;
+        const response = await this.ctx.http.get(`${utils_1.BASE_URL}${utils_1.EVENTS_PATH}`, { params: queryParams });
+        const data = response.data;
+        // API returns either a raw array or { events: [...] }
+        return Array.isArray(data) ? data : (data?.events || []);
+    }
+    async fetchRawEventsViaSearch(params) {
+        const limit = params.limit || 20;
+        const page = params.offset ? Math.floor(params.offset / limit) + 1 : 1;
+        const queryParams = {
+            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 searchData = await this.ctx.callApi('getPublicApiV1PublicSearch', queryParams);
+        return searchData?.events || [];
+    }
+}
+exports.ProbableFetcher = ProbableFetcher;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isNotFoundError(error) {
+    const status = error.response?.status;
+    if (status === 404 || status === 400)
+        return true;
+    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 isMarketNotFoundError(error) {
+    const status = error.response?.status;
+    if (status === 404 || status === 400)
+        return true;
+    if (status === 500) {
+        const data = error.response?.data;
+        const msg = typeof data === 'string' ? data : (data?.detail || data?.message || '');
+        return /not found|failed to retrieve/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/index.d.ts

@@ -27,6 +27,8 @@ export declare class ProbableExchange extends PredictionMarketExchange {
     private auth?;
     private ws?;
     private wsConfig?;
+    private readonly fetcher;
+    private readonly normalizer;
     constructor(credentials?: ExchangeCredentials, wsConfig?: ProbableWebSocketConfig);
     get name(): string;
     protected mapImplicitApiError(error: any): any;
@@ -74,6 +76,7 @@ export declare class ProbableExchange extends PredictionMarketExchange {
     fetchOrderBook(id: string): Promise<OrderBook>;
     fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     /**
      * Cancel an order.
@@ -89,7 +92,6 @@ export declare class ProbableExchange extends PredictionMarketExchange {
     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>;
 }

package/dist/exchanges/probable/index.js

@@ -2,9 +2,6 @@
 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 fetchTrades_1 = require("./fetchTrades");
 const auth_1 = require("./auth");
 const websocket_1 = require("./websocket");
 const errors_1 = require("./errors");
@@ -13,25 +10,9 @@ const clob_1 = require("@prob/clob");
 const openapi_1 = require("../../utils/openapi");
 const api_1 = require("./api");
 const utils_1 = require("./utils");
+const fetcher_1 = require("./fetcher");
+const normalizer_1 = require("./normalizer");
 const BSC_USDT_ADDRESS = '0x55d398326f99059fF775485246999027B3197955';
-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);
-}
 class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
         fetchMarkets: true,
@@ -58,6 +39,8 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
     auth;
     ws;
     wsConfig;
+    fetcher;
+    normalizer;
     constructor(credentials, wsConfig) {
         super(credentials);
         this.rateLimit = 500;
@@ -67,6 +50,13 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.probableApiSpec, utils_1.BASE_URL);
         this.defineImplicitApi(descriptor);
+        const ctx = {
+            http: this.http,
+            callApi: this.callApi.bind(this),
+            getHeaders: () => ({ 'Content-Type': 'application/json' }),
+        };
+        this.fetcher = new fetcher_1.ProbableFetcher(ctx);
+        this.normalizer = new normalizer_1.ProbableNormalizer();
     }
     get name() {
         return 'Probable';
@@ -82,13 +72,38 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
         return this.auth;
     }
     // --------------------------------------------------------------------------
-    // Market Data (read-only, no auth needed)
+    // Market Data (fetcher -> normalizer)
     // --------------------------------------------------------------------------
     async fetchMarketsImpl(params) {
-        return (0, fetchMarkets_1.fetchMarkets)(params, this.http, (tokenId) => this.callApi('getPublicApiV1Midpoint', { token_id: tokenId }), (queryParams) => this.callApi('getPublicApiV1PublicSearch', queryParams));
+        const rawMarkets = await this.fetcher.fetchRawMarkets(params);
+        const markets = rawMarkets
+            .map((raw) => this.normalizer.normalizeMarket(raw))
+            .filter((m) => m !== null);
+        // Filter by outcomeId client-side if requested
+        const filtered = params?.outcomeId
+            ? markets.filter(m => m.outcomes.some(o => o.outcomeId === params.outcomeId))
+            : markets;
+        // Slug-based exact matching for search results
+        if (params?.slug && rawMarkets.length > 0) {
+            const exact = filtered.filter(m => m.marketId === params.slug ||
+                m.url.includes(params.slug) ||
+                rawMarkets.find(r => this.normalizer.normalizeMarket(r)?.marketId === m.marketId)?._parentEvent?.slug === params.slug);
+            if (exact.length > 0) {
+                await this.normalizer.enrichMarketsWithPrices(exact, (tokenId) => this.fetcher.fetchRawMidpoint(tokenId));
+                return exact;
+            }
+        }
+        await this.normalizer.enrichMarketsWithPrices(filtered, (tokenId) => this.fetcher.fetchRawMidpoint(tokenId));
+        return filtered;
     }
     async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(params, this.http, (tokenId) => this.callApi('getPublicApiV1Midpoint', { token_id: tokenId }), (queryParams) => this.callApi('getPublicApiV1PublicSearch', queryParams));
+        const rawEvents = await this.fetcher.fetchRawEvents(params);
+        const events = rawEvents
+            .map((raw) => this.normalizer.normalizeEvent(raw))
+            .filter((e) => e !== null);
+        const allMarkets = events.flatMap((e) => e.markets);
+        await this.normalizer.enrichMarketsWithPrices(allMarkets, (tokenId) => this.fetcher.fetchRawMidpoint(tokenId));
+        return events;
     }
     /**
      * Fetch a single event by its numeric ID (Probable only).
@@ -110,7 +125,14 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
      *     print(len(event.markets), 'markets')
      */
     async getEventById(id) {
-        return (0, fetchEvents_1.fetchEventById)(id, this.http, (tokenId) => this.callApi('getPublicApiV1Midpoint', { token_id: tokenId }));
+        const raw = await this.fetcher.fetchRawEventById(id);
+        if (!raw)
+            return null;
+        const event = this.normalizer.normalizeEvent(raw);
+        if (event) {
+            await this.normalizer.enrichMarketsWithPrices(event.markets, (tokenId) => this.fetcher.fetchRawMidpoint(tokenId));
+        }
+        return event;
     }
     /**
      * Fetch a single event by its URL slug (Probable only).
@@ -130,80 +152,42 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
      *     print(event.title)
      */
     async getEventBySlug(slug) {
-        return (0, fetchEvents_1.fetchEventBySlug)(slug, this.http, (tokenId) => this.callApi('getPublicApiV1Midpoint', { token_id: tokenId }));
+        const raw = await this.fetcher.fetchRawEventBySlug(slug);
+        if (!raw)
+            return null;
+        const event = this.normalizer.normalizeEvent(raw);
+        if (event) {
+            await this.normalizer.enrichMarketsWithPrices(event.markets, (tokenId) => this.fetcher.fetchRawMidpoint(tokenId));
+        }
+        return event;
     }
     async fetchOrderBook(id) {
-        const data = await this.callApi('getPublicApiV1Book', { token_id: id });
-        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(),
-        };
+        const raw = await this.fetcher.fetchRawOrderBook(id);
+        return this.normalizer.normalizeOrderBook(raw, id);
     }
     async fetchOHLCV(id, params) {
         if (!params.resolution) {
             throw new Error('fetchOHLCV requires a resolution parameter.');
         }
-        const INTERVAL_MAP = {
-            '1m': '1m',
-            '5m': '1m',
-            '15m': '1m',
-            '1h': '1h',
-            '6h': '6h',
-            '1d': '1d',
-        };
-        const queryParams = {
-            market: id,
-            interval: INTERVAL_MAP[params.resolution] || '1h',
-        };
-        if (params.start)
-            queryParams.startTs = Math.floor(params.start.getTime() / 1000);
-        if (params.end)
-            queryParams.endTs = Math.floor(params.end.getTime() / 1000);
-        const data = await this.callApi('getPublicApiV1PricesHistory', queryParams);
-        const points = data?.history || 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);
-        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;
+        const rawPoints = await this.fetcher.fetchRawOHLCV(id, params);
+        return this.normalizer.normalizeOHLCV(rawPoints, params);
     }
     async fetchMyTrades(params) {
         const auth = this.ensureAuth();
         const address = auth.getAddress();
-        const queryParams = { user: address };
-        if (params?.limit)
+        const rawTrades = await this.fetcher.fetchRawMyTrades(params || {}, address);
+        return rawTrades.map((raw, i) => this.normalizer.normalizeUserTrade(raw, i));
+    }
+    async fetchTrades(id, params) {
+        const auth = this.ensureAuth();
+        const client = auth.getClobClient();
+        // Use CLOB client directly for trades (legacy behaviour preserved)
+        const queryParams = { tokenId: id };
+        if (params.limit)
             queryParams.limit = params.limit;
-        const data = await this.callApi('getPublicApiV1Trades', queryParams);
-        const trades = Array.isArray(data) ? data : (data.data || []);
-        return trades.map((t) => ({
-            id: String(t.tradeId || t.id || t.timestamp),
-            timestamp: typeof t.time === 'number'
-                ? (t.time > 1e12 ? t.time : t.time * 1000)
-                : Date.now(),
-            price: parseFloat(t.price || '0'),
-            amount: parseFloat(t.qty || t.size || t.amount || '0'),
-            side: (t.side || '').toLowerCase() === 'buy' ? 'buy' : 'sell',
-            orderId: t.orderId,
-        }));
+        const response = await client.getTrades(queryParams);
+        const trades = Array.isArray(response) ? response : response?.data || [];
+        return trades.map((raw, i) => this.normalizer.normalizeTrade(raw, i));
     }
     // --------------------------------------------------------------------------
     // Trading Methods
@@ -236,7 +220,6 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
                 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');
             }
@@ -365,18 +348,8 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
         try {
             const auth = this.ensureAuth();
             const address = auth.getAddress();
-            const result = await this.callApi('getPublicApiV1PositionCurrent', { user: address, limit: 500 });
-            const data = Array.isArray(result) ? result : (result?.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'),
-            }));
+            const rawItems = await this.fetcher.fetchRawPositions(address);
+            return rawItems.map((raw) => this.normalizer.normalizePosition(raw));
         }
         catch (error) {
             throw errors_1.probableErrorMapper.mapError(error);
@@ -428,11 +401,6 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
             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, this.http);
-    }
     // --------------------------------------------------------------------------
     // WebSocket Streaming (public, no auth needed)
     // --------------------------------------------------------------------------

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

@@ -0,0 +1,14 @@
+import { OHLCVParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Position } from '../../types';
+import { IExchangeNormalizer } from '../interfaces';
+import { ProbableRawMarket, ProbableRawEvent, ProbableRawOrderBook, ProbableRawPricePoint, ProbableRawTrade, ProbableRawPosition } from './fetcher';
+export declare class ProbableNormalizer implements IExchangeNormalizer<ProbableRawMarket, ProbableRawEvent> {
+    normalizeMarket(raw: ProbableRawMarket): UnifiedMarket | null;
+    normalizeEvent(raw: ProbableRawEvent): UnifiedEvent | null;
+    normalizeOrderBook(raw: ProbableRawOrderBook, _id: string): OrderBook;
+    normalizeOHLCV(rawPoints: ProbableRawPricePoint[], params: OHLCVParams): PriceCandle[];
+    normalizeTrade(raw: ProbableRawTrade, index: number): Trade;
+    normalizeUserTrade(raw: ProbableRawTrade, index: number): UserTrade;
+    normalizePosition(raw: ProbableRawPosition): Position;
+    enrichMarketsWithPrices(markets: UnifiedMarket[], callMidpoint: (tokenId: string) => Promise<any>): Promise<void>;
+}