pmxtjs 0.1.0 → 0.1.2

package/{src/exchanges/Polymarket.ts → dist/exchanges/Polymarket.js}

@@ -1,103 +1,99 @@
-import axios from 'axios';
-import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams } from '../BaseExchange';
-import { UnifiedMarket, MarketOutcome, PriceCandle, CandleInterval, OrderBook, Trade } from '../types';
-
-export class PolymarketExchange extends PredictionMarketExchange {
-    get name(): string {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolymarketExchange = void 0;
+const axios_1 = __importDefault(require("axios"));
+const BaseExchange_1 = require("../BaseExchange");
+class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
+    constructor() {
+        super(...arguments);
+        // Utilizing the Gamma API for rich metadata and list view data
+        this.baseUrl = 'https://gamma-api.polymarket.com/events';
+        // CLOB API for orderbook, trades, and timeseries
+        this.clobUrl = 'https://clob.polymarket.com';
+    }
+    get name() {
         return 'Polymarket';
     }
-
-    // Utilizing the Gamma API for rich metadata and list view data
-    private readonly baseUrl = 'https://gamma-api.polymarket.com/events';
-    // CLOB API for orderbook, trades, and timeseries
-    private readonly clobUrl = 'https://clob.polymarket.com';
-
-    async fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]> {
-        const limit = params?.limit || 200;  // Higher default for better coverage
+    async fetchMarkets(params) {
+        const limit = params?.limit || 200; // Higher default for better coverage
         const offset = params?.offset || 0;
-
         // Map generic sort params to Polymarket Gamma API params
-        let queryParams: any = {
+        let queryParams = {
             active: 'true',
             closed: 'false',
             limit: limit,
             offset: offset,
         };
-
         // Gamma API uses 'order' and 'ascending' for sorting
         if (params?.sort === 'volume') {
             queryParams.order = 'volume';
             queryParams.ascending = 'false';
-        } else if (params?.sort === 'newest') {
+        }
+        else if (params?.sort === 'newest') {
             queryParams.order = 'startDate';
             queryParams.ascending = 'false';
-        } else if (params?.sort === 'liquidity') {
+        }
+        else if (params?.sort === 'liquidity') {
             // queryParams.order = 'liquidity';
-        } else {
+        }
+        else {
             // Default: do not send order param to avoid 422
         }
-
         try {
             // Fetch active events from Gamma
-            const response = await axios.get(this.baseUrl, {
+            const response = await axios_1.default.get(this.baseUrl, {
                 params: queryParams
             });
-
             const events = response.data;
-            const unifiedMarkets: UnifiedMarket[] = [];
-
+            const unifiedMarkets = [];
             for (const event of events) {
                 // Each event is a container (e.g. "US Election"). 
                 // It contains specific "markets" (e.g. "Winner", "Pop Vote").
-                if (!event.markets) continue;
-
+                if (!event.markets)
+                    continue;
                 for (const market of event.markets) {
-                    const outcomes: MarketOutcome[] = [];
-
+                    const outcomes = [];
                     // Polymarket Gamma often returns 'outcomes' and 'outcomePrices' as stringified JSON keys.
-                    let outcomeLabels: string[] = [];
-                    let outcomePrices: string[] = [];
-
+                    let outcomeLabels = [];
+                    let outcomePrices = [];
                     try {
                         outcomeLabels = typeof market.outcomes === 'string' ? JSON.parse(market.outcomes) : (market.outcomes || []);
                         outcomePrices = typeof market.outcomePrices === 'string' ? JSON.parse(market.outcomePrices) : (market.outcomePrices || []);
-                    } catch (e) {
-                        console.warn(`Failed to parse outcomes for market ${market.id}`, e);
                     }
-
+                    catch (e) {
+                    }
                     // Extract CLOB token IDs for granular operations
-                    let clobTokenIds: string[] = [];
+                    let clobTokenIds = [];
                     try {
                         clobTokenIds = typeof market.clobTokenIds === 'string' ? JSON.parse(market.clobTokenIds) : (market.clobTokenIds || []);
-                    } catch (e) {
-                        console.warn(`Failed to parse clobTokenIds for market ${market.id}`, e);
                     }
-
+                    catch (e) {
+                    }
                     // Extract candidate/option name from market question for better outcome labels
-                    let candidateName: string | null = null;
+                    let candidateName = null;
                     if (market.question && market.groupItemTitle) {
                         candidateName = market.groupItemTitle;
                     }
-
                     if (outcomeLabels.length > 0) {
-                        outcomeLabels.forEach((label: string, index: number) => {
+                        outcomeLabels.forEach((label, index) => {
                             const rawPrice = outcomePrices[index] || "0";
-
                             // For Yes/No markets with specific candidates, use the candidate name
                             let outcomeLabel = label;
                             if (candidateName && label.toLowerCase() === 'yes') {
                                 outcomeLabel = candidateName;
-                            } else if (candidateName && label.toLowerCase() === 'no') {
+                            }
+                            else if (candidateName && label.toLowerCase() === 'no') {
                                 outcomeLabel = `Not ${candidateName}`;
                             }
-
                             // 24h Price Change
                             // Polymarket API provides 'oneDayPriceChange' on the market object
                             let priceChange = 0;
                             if (index === 0 || label.toLowerCase() === 'yes' || (candidateName && label === candidateName)) {
                                 priceChange = Number(market.oneDayPriceChange || 0);
                             }
-
                             outcomes.push({
                                 id: String(index),
                                 label: outcomeLabel,
@@ -109,7 +105,6 @@ export class PolymarketExchange extends PredictionMarketExchange {
                             });
                         });
                     }
-
                     unifiedMarkets.push({
                         id: market.id,
                         title: market.question ? `${event.title} - ${market.question}` : event.title,
@@ -123,115 +118,105 @@ export class PolymarketExchange extends PredictionMarketExchange {
                         url: `https://polymarket.com/event/${event.slug}`,
                         image: event.image || market.image || `https://polymarket.com/api/og?slug=${event.slug}`,
                         category: event.category || event.tags?.[0]?.label,
-                        tags: event.tags?.map((t: any) => t.label) || []
+                        tags: event.tags?.map((t) => t.label) || []
                     });
                 }
             }
-
             // Client-side Sort capability to ensure contract fulfillment
             // Often API filters are "good effort" or apply to the 'event' but not the 'market'
             if (params?.sort === 'volume') {
                 unifiedMarkets.sort((a, b) => b.volume24h - a.volume24h);
-            } else if (params?.sort === 'newest') {
+            }
+            else if (params?.sort === 'newest') {
                 // unifiedMarkets.sort((a, b) => b.resolutionDate.getTime() - a.resolutionDate.getTime()); // Not quite 'newest'
-            } else if (params?.sort === 'liquidity') {
+            }
+            else if (params?.sort === 'liquidity') {
                 unifiedMarkets.sort((a, b) => b.liquidity - a.liquidity);
-            } else {
+            }
+            else {
                 // Default volume sort
                 unifiedMarkets.sort((a, b) => b.volume24h - a.volume24h);
             }
-
             // Respect limit strictly after flattening 
             return unifiedMarkets.slice(0, limit);
-
-        } catch (error) {
+        }
+        catch (error) {
             console.error("Error fetching Polymarket data:", error);
             return [];
         }
     }
-
-    async searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]> {
+    async searchMarkets(query, params) {
         // Polymarket Gamma API doesn't support native search
         // Fetch a larger batch and filter client-side
         const searchLimit = 100; // Fetch more markets to search through
-
         try {
             // Fetch markets with a higher limit
             const markets = await this.fetchMarkets({
                 ...params,
                 limit: searchLimit
             });
-
             // Client-side text filtering
             const lowerQuery = query.toLowerCase();
-            const filtered = markets.filter(market =>
-                market.title.toLowerCase().includes(lowerQuery) ||
-                market.description.toLowerCase().includes(lowerQuery)
-            );
-
+            const filtered = markets.filter(market => market.title.toLowerCase().includes(lowerQuery) ||
+                market.description.toLowerCase().includes(lowerQuery));
             // Apply limit to filtered results
             const limit = params?.limit || 20;
             return filtered.slice(0, limit);
-
-        } catch (error) {
+        }
+        catch (error) {
             console.error("Error searching Polymarket data:", error);
             return [];
         }
     }
-
     /**
      * Fetch specific markets by their URL slug.
      * Useful for looking up a specific event from a URL.
      * @param slug - The event slug (e.g. "will-fed-cut-rates-in-march")
      */
-    async getMarketsBySlug(slug: string): Promise<UnifiedMarket[]> {
+    async getMarketsBySlug(slug) {
         try {
-            const response = await axios.get(this.baseUrl, {
+            const response = await axios_1.default.get(this.baseUrl, {
                 params: { slug: slug }
             });
-
             const events = response.data;
-            if (!events || events.length === 0) return [];
-
+            if (!events || events.length === 0)
+                return [];
             // We can reuse the logic from fetchMarkets if we extract it, 
             // but for now I'll duplicate the extraction logic to keep it self-contained
             // and avoid safe refactoring risks.
             // Actually, fetchMarkets is built to work with the Gamma response structure.
             // So we can manually map the response using the same logic.
-
-            const unifiedMarkets: UnifiedMarket[] = [];
-
+            const unifiedMarkets = [];
             for (const event of events) {
-                if (!event.markets) continue;
-
+                if (!event.markets)
+                    continue;
                 for (const market of event.markets) {
-                    const outcomes: MarketOutcome[] = [];
-                    let outcomeLabels: string[] = [];
-                    let outcomePrices: string[] = [];
-                    let clobTokenIds: string[] = [];
-
+                    const outcomes = [];
+                    let outcomeLabels = [];
+                    let outcomePrices = [];
+                    let clobTokenIds = [];
                     try {
                         outcomeLabels = typeof market.outcomes === 'string' ? JSON.parse(market.outcomes) : (market.outcomes || []);
                         outcomePrices = typeof market.outcomePrices === 'string' ? JSON.parse(market.outcomePrices) : (market.outcomePrices || []);
                         clobTokenIds = typeof market.clobTokenIds === 'string' ? JSON.parse(market.clobTokenIds) : (market.clobTokenIds || []);
-                    } catch (e) { console.warn(`Parse error for market ${market.id}`, e); }
-
+                    }
+                    catch (e) { /* ignore */ }
                     let candidateName = market.groupItemTitle;
-                    if (!candidateName && market.question) candidateName = market.question;
-
+                    if (!candidateName && market.question)
+                        candidateName = market.question;
                     if (outcomeLabels.length > 0) {
-                        outcomeLabels.forEach((label: string, index: number) => {
+                        outcomeLabels.forEach((label, index) => {
                             let outcomeLabel = label;
                             // Clean up Yes/No labels if candidate name is available
-                            if (candidateName && label.toLowerCase() === 'yes') outcomeLabel = candidateName;
-                            else if (candidateName && label.toLowerCase() === 'no') outcomeLabel = `Not ${candidateName}`;
-
+                            if (candidateName && label.toLowerCase() === 'yes')
+                                outcomeLabel = candidateName;
+                            else if (candidateName && label.toLowerCase() === 'no')
+                                outcomeLabel = `Not ${candidateName}`;
                             // 24h Price Change Logic
                             let priceChange = 0;
                             if (index === 0 || label.toLowerCase() === 'yes' || (candidateName && label === candidateName)) {
                                 priceChange = Number(market.oneDayPriceChange || 0);
                             }
-
                             outcomes.push({
                                 id: String(index),
                                 label: outcomeLabel,
@@ -243,7 +228,6 @@ export class PolymarketExchange extends PredictionMarketExchange {
                             });
                         });
                     }
-
                     unifiedMarkets.push({
                         id: market.id,
                         title: event.title,
@@ -257,23 +241,22 @@ export class PolymarketExchange extends PredictionMarketExchange {
                         url: `https://polymarket.com/event/${event.slug}`,
                         image: event.image || market.image,
                         category: event.category || event.tags?.[0]?.label,
-                        tags: event.tags?.map((t: any) => t.label) || []
+                        tags: event.tags?.map((t) => t.label) || []
                     });
                 }
             }
             return unifiedMarkets;
-
-        } catch (error) {
+        }
+        catch (error) {
             console.error(`Error fetching Polymarket slug ${slug}:`, error);
             return [];
         }
     }
-
     /**
      * Map our generic CandleInterval to Polymarket's fidelity (in minutes)
      */
-    private mapIntervalToFidelity(interval: CandleInterval): number {
-        const mapping: Record<CandleInterval, number> = {
+    mapIntervalToFidelity(interval) {
+        const mapping = {
             '1m': 1,
             '5m': 5,
             '15m': 15,
@@ -283,26 +266,22 @@ export class PolymarketExchange extends PredictionMarketExchange {
         };
         return mapping[interval];
     }
-
     /**
      * Fetch historical price data (OHLCV candles) for a specific token.
      * @param id - The CLOB token ID (e.g., outcome token ID)
      */
-    async getMarketHistory(id: string, params: HistoryFilterParams): Promise<PriceCandle[]> {
+    async getMarketHistory(id, params) {
         // ID Validation: Polymarket CLOB requires a Token ID (long numeric string) not a Market ID
         if (id.length < 10 && /^\d+$/.test(id)) {
             throw new Error(`Invalid ID for Polymarket history: "${id}". You provided a Market ID, but Polymarket's CLOB API requires a Token ID. Use outcome.metadata.clobTokenId instead.`);
         }
-
         try {
             const fidelity = this.mapIntervalToFidelity(params.resolution);
             const nowTs = Math.floor(Date.now() / 1000);
-
             // 1. Smart Lookback Calculation
             // If start/end not provided, calculate window based on limit * resolution
             let startTs = params.start ? Math.floor(params.start.getTime() / 1000) : 0;
             let endTs = params.end ? Math.floor(params.end.getTime() / 1000) : nowTs;
-
             if (!params.start) {
                 // Default limit is usually 20 in the example, but safety margin is good.
                 // If limit is not set, we default to 100 candles.
@@ -311,29 +290,23 @@ export class PolymarketExchange extends PredictionMarketExchange {
                 const durationSeconds = count * fidelity * 60;
                 startTs = endTs - durationSeconds;
             }
-
-            const queryParams: any = {
+            const queryParams = {
                 market: id,
                 fidelity: fidelity,
                 startTs: startTs,
                 endTs: endTs
             };
-
-            const response = await axios.get(`${this.clobUrl}/prices-history`, {
+            const response = await axios_1.default.get(`${this.clobUrl}/prices-history`, {
                 params: queryParams
             });
-
             const history = response.data.history || [];
-
             // 2. Align Timestamps (Snap to Grid)
             // Polymarket returns random tick timestamps (e.g. 1:00:21).
             // We want to normalize this to the start of the bucket (1:00:00).
             const resolutionMs = fidelity * 60 * 1000;
-
-            const candles: PriceCandle[] = history.map((item: any) => {
+            const candles = history.map((item) => {
                 const rawMs = item.t * 1000;
                 const snappedMs = Math.floor(rawMs / resolutionMs) * resolutionMs;
-
                 return {
                     timestamp: snappedMs, // Aligned timestamp
                     open: item.p,
@@ -343,16 +316,14 @@ export class PolymarketExchange extends PredictionMarketExchange {
                     volume: undefined
                 };
             });
-
             // Apply limit if specified
             if (params.limit && candles.length > params.limit) {
                 return candles.slice(-params.limit);
             }
-
             return candles;
-
-        } catch (error: any) {
-            if (axios.isAxiosError(error) && error.response) {
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && error.response) {
                 const apiError = error.response.data?.error || error.response.data?.message || "Unknown API Error";
                 throw new Error(`Polymarket History API Error (${error.response.status}): ${apiError}. Used ID: ${id}`);
             }
@@ -360,61 +331,53 @@ export class PolymarketExchange extends PredictionMarketExchange {
             throw error;
         }
     }
-
     /**
      * Fetch the current order book for a specific token.
      * @param id - The CLOB token ID
      */
-    async getOrderBook(id: string): Promise<OrderBook> {
+    async getOrderBook(id) {
         try {
-            const response = await axios.get(`${this.clobUrl}/book`, {
+            const response = await axios_1.default.get(`${this.clobUrl}/book`, {
                 params: { token_id: id }
             });
-
             const data = response.data;
-
             // Response format: { bids: [{price: "0.52", size: "100"}], asks: [...] }
-            const bids = (data.bids || []).map((level: any) => ({
+            const bids = (data.bids || []).map((level) => ({
                 price: parseFloat(level.price),
                 size: parseFloat(level.size)
-            })).sort((a: { price: number, size: number }, b: { price: number, size: number }) => b.price - a.price); // Sort Bids Descending (Best/Highest first)
-
-            const asks = (data.asks || []).map((level: any) => ({
+            })).sort((a, b) => b.price - a.price); // Sort Bids Descending (Best/Highest first)
+            const asks = (data.asks || []).map((level) => ({
                 price: parseFloat(level.price),
                 size: parseFloat(level.size)
-            })).sort((a: { price: number, size: number }, b: { price: number, size: number }) => a.price - b.price); // Sort Asks Ascending (Best/Lowest first)
-
+            })).sort((a, b) => a.price - b.price); // Sort Asks Ascending (Best/Lowest first)
             return {
                 bids,
                 asks,
                 timestamp: data.timestamp ? new Date(data.timestamp).getTime() : Date.now()
             };
-
-        } catch (error) {
+        }
+        catch (error) {
             console.error(`Error fetching Polymarket orderbook for ${id}:`, error);
             return { bids: [], asks: [] };
         }
     }
-
     /**
      * Fetch raw trade history for a specific token.
      * @param id - The CLOB token ID
-     * 
+     *
      * NOTE: Polymarket's /trades endpoint currently requires L2 Authentication (API Key).
      * This method will return an empty array if an API key is not provided in headers.
      * Use getMarketHistory for public historical price data instead.
      */
-    async getTradeHistory(id: string, params: HistoryFilterParams): Promise<Trade[]> {
+    async getTradeHistory(id, params) {
         // ID Validation
         if (id.length < 10 && /^\d+$/.test(id)) {
             throw new Error(`Invalid ID for Polymarket trades: "${id}". You provided a Market ID, but Polymarket's CLOB API requires a Token ID.`);
         }
-
         try {
-            const queryParams: any = {
+            const queryParams = {
                 market: id
             };
-
             // Add time filters if provided
             if (params.start) {
                 queryParams.after = Math.floor(params.start.getTime() / 1000);
@@ -422,31 +385,26 @@ export class PolymarketExchange extends PredictionMarketExchange {
             if (params.end) {
                 queryParams.before = Math.floor(params.end.getTime() / 1000);
             }
-
-            const response = await axios.get(`${this.clobUrl}/trades`, {
+            const response = await axios_1.default.get(`${this.clobUrl}/trades`, {
                 params: queryParams
             });
-
             // Response is an array of trade objects
             const trades = response.data || [];
-
-            const mappedTrades: Trade[] = trades.map((trade: any) => ({
+            const mappedTrades = trades.map((trade) => ({
                 id: trade.id || `${trade.timestamp}-${trade.price}`,
                 timestamp: trade.timestamp * 1000, // Convert to milliseconds
                 price: parseFloat(trade.price),
                 amount: parseFloat(trade.size || trade.amount || 0),
                 side: trade.side === 'BUY' ? 'buy' : trade.side === 'SELL' ? 'sell' : 'unknown'
             }));
-
             // Apply limit if specified
             if (params.limit && mappedTrades.length > params.limit) {
                 return mappedTrades.slice(-params.limit); // Return most recent N trades
             }
-
             return mappedTrades;
-
-        } catch (error: any) {
-            if (axios.isAxiosError(error) && error.response) {
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && error.response) {
                 const apiError = error.response.data?.error || error.response.data?.message || "Unknown API Error";
                 throw new Error(`Polymarket Trades API Error (${error.response.status}): ${apiError}. Used ID: ${id}`);
             }
@@ -455,3 +413,4 @@ export class PolymarketExchange extends PredictionMarketExchange {
         }
     }
 }
+exports.PolymarketExchange = PolymarketExchange;

package/{src/index.ts → dist/index.d.ts}

@@ -2,4 +2,3 @@ export * from './BaseExchange';
 export * from './types';
 export * from './exchanges/Polymarket';
 export * from './exchanges/Kalshi';
-

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./BaseExchange"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./exchanges/Polymarket"), exports);
+__exportStar(require("./exchanges/Kalshi"), exports);

package/{src/types.ts → dist/types.d.ts}

@@ -1,8 +1,3 @@
-
-// ----------------------------------------------------------------------------
-// Core Data Models
-// ----------------------------------------------------------------------------
-
 export interface MarketOutcome {
     id: string;
     label: string;
@@ -10,28 +5,22 @@ export interface MarketOutcome {
     priceChange24h?: number;
     metadata?: Record<string, any>;
 }
-
 export interface UnifiedMarket {
     id: string;
     title: string;
     description: string;
     outcomes: MarketOutcome[];
-
     resolutionDate: Date;
     volume24h: number;
-    volume?: number; // Total / Lifetime volume
+    volume?: number;
     liquidity: number;
     openInterest?: number;
-
     url: string;
     image?: string;
-
     category?: string;
     tags?: string[];
 }
-
 export type CandleInterval = '1m' | '5m' | '15m' | '1h' | '6h' | '1d';
-
 export interface PriceCandle {
     timestamp: number;
     open: number;
@@ -40,18 +29,15 @@ export interface PriceCandle {
     close: number;
     volume?: number;
 }
-
 export interface OrderLevel {
-    price: number; // 0.0 to 1.0 (probability)
-    size: number;  // contracts/shares
+    price: number;
+    size: number;
 }
-
 export interface OrderBook {
     bids: OrderLevel[];
     asks: OrderLevel[];
     timestamp?: number;
 }
-
 export interface Trade {
     id: string;
     timestamp: number;

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+// ----------------------------------------------------------------------------
+// Core Data Models
+// ----------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "pmxtjs",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "pmxt is a unified prediction market data API. The ccxt for prediction markets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "API_REFERENCE.md"
+  ],
   "directories": {
     "example": "examples",
     "test": "test"
@@ -19,5 +23,9 @@
   "dependencies": {
     "axios": "^1.7.9",
     "tsx": "^4.21.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@types/node": "^25.0.3"
   }
 }