pmxtjs 0.1.0 → 0.1.1

package/test/exchanges/polymarket/MarketHistory.test.ts

@@ -1,207 +0,0 @@
-import axios from 'axios';
-import { PolymarketExchange } from '../../../src/exchanges/Polymarket';
-
-/**
- * Polymarket getMarketHistory() Test
- * 
- * What: Tests fetching historical price data from CLOB API.
- * Why: Historical data is essential for charting and analysis.
- * How: Mocks Polymarket prices-history API responses and verifies data transformation.
- */
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-describe('PolymarketExchange - getMarketHistory', () => {
-    let exchange: PolymarketExchange;
-
-    beforeEach(() => {
-        exchange = new PolymarketExchange();
-        jest.clearAllMocks();
-    });
-
-    it('should fetch and parse price history', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                history: [
-                    { t: 1704067200, p: 0.52 },
-                    { t: 1704070800, p: 0.53 },
-                    { t: 1704074400, p: 0.54 }
-                ]
-            }
-        });
-
-        const history = await exchange.getMarketHistory('token123456789', { resolution: '1h' });
-
-        expect(history.length).toBe(3);
-        expect(history[0].close).toBe(0.52);
-        expect(history[1].close).toBe(0.53);
-        expect(history[2].close).toBe(0.54);
-    });
-
-    it('should convert timestamps to milliseconds', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                history: [{ t: 1704067200, p: 0.50 }]
-            }
-        });
-
-        const history = await exchange.getMarketHistory('token123456789', { resolution: '1h' });
-
-        expect(history[0].timestamp).toBeGreaterThan(1704067200);
-        expect(history[0].timestamp).toBeLessThanOrEqual(1704067200 * 1000 + 3600000);
-    });
-
-    it('should align timestamps to interval grid', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                history: [
-                    { t: 1704067221, p: 0.50 }  // 00:00:21
-                ]
-            }
-        });
-
-        const history = await exchange.getMarketHistory('token123456789', { resolution: '1h' });
-
-        // Should snap to 00:00:00
-        const expectedSnap = Math.floor(1704067221 / 3600) * 3600 * 1000;
-        expect(history[0].timestamp).toBe(expectedSnap);
-    });
-
-    it('should respect limit parameter', async () => {
-        const mockHistory = Array.from({ length: 100 }, (_, i) => ({
-            t: 1704067200 + (i * 3600),
-            p: 0.50 + (i * 0.001)
-        }));
-
-        mockedAxios.get.mockResolvedValue({
-            data: { history: mockHistory }
-        });
-
-        const history = await exchange.getMarketHistory('token123456789', {
-            resolution: '1h',
-            limit: 20
-        });
-
-        expect(history.length).toBe(20);
-    });
-
-    it('should map intervals to fidelity correctly', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: { history: [] }
-        });
-
-        await exchange.getMarketHistory('token123456789', { resolution: '1m' });
-        expect(mockedAxios.get).toHaveBeenCalledWith(
-            expect.any(String),
-            expect.objectContaining({
-                params: expect.objectContaining({ fidelity: 1 })
-            })
-        );
-
-        jest.clearAllMocks();
-        mockedAxios.get.mockResolvedValue({ data: { history: [] } });
-
-        await exchange.getMarketHistory('token123456789', { resolution: '1d' });
-        expect(mockedAxios.get).toHaveBeenCalledWith(
-            expect.any(String),
-            expect.objectContaining({
-                params: expect.objectContaining({ fidelity: 1440 })
-            })
-        );
-    });
-
-    it('should handle start and end timestamps', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: { history: [] }
-        });
-
-        const start = new Date('2025-01-01T00:00:00Z');
-        const end = new Date('2025-01-02T00:00:00Z');
-
-        await exchange.getMarketHistory('token123456789', {
-            resolution: '1h',
-            start,
-            end
-        });
-
-        expect(mockedAxios.get).toHaveBeenCalledWith(
-            expect.any(String),
-            expect.objectContaining({
-                params: expect.objectContaining({
-                    startTs: Math.floor(start.getTime() / 1000),
-                    endTs: Math.floor(end.getTime() / 1000)
-                })
-            })
-        );
-    });
-
-    it('should calculate smart lookback when start not provided', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: { history: [] }
-        });
-
-        await exchange.getMarketHistory('token123456789', {
-            resolution: '1h',
-            limit: 24
-        });
-
-        const call = mockedAxios.get.mock.calls[0][1];
-        const params = call?.params;
-
-        expect(params.startTs).toBeDefined();
-        expect(params.endTs).toBeDefined();
-        // Should be approximately 24 hours worth of data
-        const duration = params.endTs - params.startTs;
-        expect(duration).toBeGreaterThan(24 * 60 * 60 * 0.9);  // Allow 10% margin
-        expect(duration).toBeLessThan(24 * 60 * 60 * 1.1);
-    });
-
-    it('should handle empty history array', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: { history: [] }
-        });
-
-        const history = await exchange.getMarketHistory('token123456789', { resolution: '1h' });
-
-        expect(history).toEqual([]);
-    });
-
-    it('should set OHLC to same value (synthetic candles)', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                history: [{ t: 1704067200, p: 0.52 }]
-            }
-        });
-
-        const history = await exchange.getMarketHistory('token123456789', { resolution: '1h' });
-
-        expect(history[0].open).toBe(0.52);
-        expect(history[0].high).toBe(0.52);
-        expect(history[0].low).toBe(0.52);
-        expect(history[0].close).toBe(0.52);
-    });
-
-    it('should throw error for invalid token ID format', async () => {
-        await expect(exchange.getMarketHistory('123', { resolution: '1h' }))
-            .rejects
-            .toThrow(/Invalid ID/i);
-    });
-
-    it('should handle API errors with detailed messages', async () => {
-        const error = {
-            response: {
-                status: 400,
-                data: { error: 'Invalid token ID' }
-            },
-            isAxiosError: true
-        };
-        mockedAxios.get.mockRejectedValue(error);
-        // @ts-expect-error - Mock type mismatch is expected in tests
-        mockedAxios.isAxiosError = jest.fn().mockReturnValue(true);
-
-        await expect(exchange.getMarketHistory('token123456789', { resolution: '1h' }))
-            .rejects
-            .toThrow(/History API Error/i);
-    });
-});

package/test/exchanges/polymarket/OrderBook.test.ts

@@ -1,167 +0,0 @@
-import axios from 'axios';
-import { PolymarketExchange } from '../../../src/exchanges/Polymarket';
-
-/**
- * Polymarket getOrderBook() Test
- * 
- * What: Tests fetching and parsing of CLOB order book data.
- * Why: Order book data is critical for trading and price discovery.
- * How: Mocks Polymarket CLOB API responses and verifies correct parsing and sorting.
- */
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-describe('PolymarketExchange - getOrderBook', () => {
-    let exchange: PolymarketExchange;
-
-    beforeEach(() => {
-        exchange = new PolymarketExchange();
-        jest.clearAllMocks();
-    });
-
-    it('should parse orderbook data correctly', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                bids: [
-                    { price: '0.52', size: '100' },
-                    { price: '0.51', size: '250' },
-                    { price: '0.50', size: '500' }
-                ],
-                asks: [
-                    { price: '0.53', size: '150' },
-                    { price: '0.54', size: '200' },
-                    { price: '0.55', size: '300' }
-                ],
-                timestamp: '2025-01-08T12:00:00Z'
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('token123456789');
-
-        expect(orderbook.bids).toBeDefined();
-        expect(orderbook.asks).toBeDefined();
-        expect(orderbook.bids.length).toBe(3);
-        expect(orderbook.asks.length).toBe(3);
-    });
-
-    it('should convert string prices to numbers', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                bids: [{ price: '0.52', size: '100' }],
-                asks: [{ price: '0.53', size: '150' }]
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('token123456789');
-
-        expect(typeof orderbook.bids[0].price).toBe('number');
-        expect(typeof orderbook.bids[0].size).toBe('number');
-        expect(orderbook.bids[0].price).toBe(0.52);
-        expect(orderbook.bids[0].size).toBe(100);
-    });
-
-    it('should sort bids in descending order', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                bids: [
-                    { price: '0.50', size: '100' },
-                    { price: '0.52', size: '200' },
-                    { price: '0.51', size: '150' }
-                ],
-                asks: []
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('token123456789');
-
-        expect(orderbook.bids[0].price).toBeGreaterThanOrEqual(orderbook.bids[1].price);
-        expect(orderbook.bids[1].price).toBeGreaterThanOrEqual(orderbook.bids[2].price);
-    });
-
-    it('should sort asks in ascending order', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                bids: [],
-                asks: [
-                    { price: '0.55', size: '100' },
-                    { price: '0.53', size: '200' },
-                    { price: '0.54', size: '150' }
-                ]
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('token123456789');
-
-        expect(orderbook.asks[0].price).toBeLessThanOrEqual(orderbook.asks[1].price);
-        expect(orderbook.asks[1].price).toBeLessThanOrEqual(orderbook.asks[2].price);
-    });
-
-    it('should handle empty orderbook', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                bids: [],
-                asks: []
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('token123456789');
-
-        expect(orderbook.bids).toEqual([]);
-        expect(orderbook.asks).toEqual([]);
-    });
-
-    it('should include timestamp', async () => {
-        const mockTimestamp = '2025-01-08T12:00:00Z';
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                bids: [{ price: '0.52', size: '100' }],
-                asks: [{ price: '0.53', size: '150' }],
-                timestamp: mockTimestamp
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('token123456789');
-
-        expect(orderbook.timestamp).toBeDefined();
-        expect(typeof orderbook.timestamp).toBe('number');
-    });
-
-    it('should handle missing timestamp with current time', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                bids: [{ price: '0.52', size: '100' }],
-                asks: [{ price: '0.53', size: '150' }]
-            }
-        });
-
-        const before = Date.now();
-        const orderbook = await exchange.getOrderBook('token123456789');
-        const after = Date.now();
-
-        expect(orderbook.timestamp).toBeGreaterThanOrEqual(before);
-        expect(orderbook.timestamp).toBeLessThanOrEqual(after);
-    });
-
-    it('should handle missing bids/asks fields', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {}
-        });
-
-        const orderbook = await exchange.getOrderBook('token123456789');
-
-        expect(orderbook.bids).toEqual([]);
-        expect(orderbook.asks).toEqual([]);
-    });
-
-    it('should return empty orderbook on error', async () => {
-        mockedAxios.get.mockRejectedValue(new Error('API Error'));
-        const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-
-        const orderbook = await exchange.getOrderBook('token123456789');
-
-        expect(orderbook).toEqual({ bids: [], asks: [] });
-        expect(consoleSpy).toHaveBeenCalled();
-        consoleSpy.mockRestore();
-    });
-});

package/test/exchanges/polymarket/RequestParameters.test.ts

@@ -1,39 +0,0 @@
-import axios from 'axios';
-import { PolymarketExchange } from '../../../src/exchanges/Polymarket';
-
-/**
- * Polymarket Request Parameters Test
- * 
- * What: Tests if internal filter parameters are correctly mapped to Polymarket API query params.
- * Why: Different exchanges use different parameter names (e.g., 'sort' vs 'order', 'limit' vs 'qty').
- *      We must ensure our unified interface maps correctly to each exchange's native API.
- * How: Mocks axios and inspects the 'params' object passed to the get call.
- */
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-describe('PolymarketExchange - Request Parameters Mapping', () => {
-    let exchange: PolymarketExchange;
-
-    beforeEach(() => {
-        exchange = new PolymarketExchange();
-        jest.clearAllMocks();
-    });
-
-    it('should map limit and sort parameters correctly', async () => {
-        mockedAxios.get.mockResolvedValue({ data: [] });
-
-        await exchange.fetchMarkets({ limit: 50, sort: 'volume' });
-
-        expect(mockedAxios.get).toHaveBeenCalledWith(
-            expect.stringContaining('events'),
-            expect.objectContaining({
-                params: expect.objectContaining({
-                    limit: 50,
-                    order: 'volume'
-                })
-            })
-        );
-    });
-});

package/test/exchanges/polymarket/SearchMarkets.test.ts

@@ -1,176 +0,0 @@
-import axios from 'axios';
-import { PolymarketExchange } from '../../../src/exchanges/Polymarket';
-
-/**
- * Polymarket searchMarkets() Test
- * 
- * What: Tests the search functionality for finding markets by query string.
- * Why: Search is a critical user-facing feature that must work reliably.
- * How: Mocks API responses with various market data and verifies client-side filtering.
- */
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-describe('PolymarketExchange - searchMarkets', () => {
-    let exchange: PolymarketExchange;
-
-    beforeEach(() => {
-        exchange = new PolymarketExchange();
-        jest.clearAllMocks();
-    });
-
-    it('should filter markets by title', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: [
-                {
-                    id: 'event-1',
-                    slug: 'fed-rate-decision',
-                    title: 'Federal Reserve Rate Decision',
-                    description: 'Federal Reserve interest rate decision',
-                    markets: [{
-                        id: 'market-1',
-                        question: 'Will rates be cut?',
-                        description: 'Federal Reserve rate cut prediction',
-                        outcomes: '["Yes", "No"]',
-                        outcomePrices: '["0.52", "0.48"]',
-                        clobTokenIds: '["token1", "token2"]',
-                        endDate: '2025-12-31T00:00:00Z',
-                        volume24hr: '100000'
-                    }]
-                },
-                {
-                    id: 'event-2',
-                    slug: 'election-2024',
-                    title: 'Presidential Election 2024',
-                    description: 'US Presidential Election',
-                    markets: [{
-                        id: 'market-2',
-                        question: 'Winner?',
-                        description: 'Election winner prediction',
-                        outcomes: '["Trump", "Biden"]',
-                        outcomePrices: '["0.48", "0.52"]',
-                        clobTokenIds: '["token3", "token4"]',
-                        endDate: '2024-11-05T00:00:00Z',
-                        volume24hr: '500000'
-                    }]
-                }
-            ]
-        });
-
-        const results = await exchange.searchMarkets('federal');
-
-        expect(results.length).toBeGreaterThan(0);
-        expect(results[0].title.toLowerCase()).toContain('federal');
-    });
-
-    it('should filter markets by description', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: [{
-                id: 'event-1',
-                slug: 'climate-policy',
-                title: 'Climate Policy',
-                description: 'Will Congress pass climate legislation?',
-                markets: [{
-                    id: 'market-1',
-                    question: 'Pass by 2025?',
-                    description: 'Detailed climate change policy information',
-                    outcomes: '["Yes", "No"]',
-                    outcomePrices: '["0.30", "0.70"]',
-                    clobTokenIds: '["token1", "token2"]',
-                    endDate: '2025-12-31T00:00:00Z',
-                    volume24hr: '50000'
-                }]
-            }]
-        });
-
-        const results = await exchange.searchMarkets('climate');
-
-        expect(results.length).toBeGreaterThan(0);
-    });
-
-    it('should respect limit parameter', async () => {
-        const mockEvents = Array.from({ length: 30 }, (_, i) => ({
-            id: `event-${i}`,
-            slug: `test-event-${i}`,
-            title: `Test Market ${i}`,
-            markets: [{
-                id: `market-${i}`,
-                question: 'Test question',
-                outcomes: '["Yes", "No"]',
-                outcomePrices: '["0.50", "0.50"]',
-                clobTokenIds: '["token1", "token2"]',
-                endDate: '2025-12-31T00:00:00Z',
-                volume24hr: '10000'
-            }]
-        }));
-
-        mockedAxios.get.mockResolvedValue({ data: mockEvents });
-
-        const results = await exchange.searchMarkets('test', { limit: 5 });
-
-        expect(results.length).toBeLessThanOrEqual(5);
-    });
-
-    it('should return empty array when no matches found', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: [{
-                id: 'event-1',
-                slug: 'unrelated',
-                title: 'Completely Different Topic',
-                markets: [{
-                    id: 'market-1',
-                    question: 'Something else',
-                    outcomes: '["Yes", "No"]',
-                    outcomePrices: '["0.50", "0.50"]',
-                    clobTokenIds: '["token1", "token2"]',
-                    endDate: '2025-12-31T00:00:00Z',
-                    volume24hr: '10000'
-                }]
-            }]
-        });
-
-        const results = await exchange.searchMarkets('nonexistent query string');
-
-        expect(results).toEqual([]);
-    });
-
-    it('should handle search errors gracefully', async () => {
-        mockedAxios.get.mockRejectedValue(new Error('Search failed'));
-        const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-
-        const results = await exchange.searchMarkets('test');
-
-        expect(results).toEqual([]);
-        expect(consoleSpy).toHaveBeenCalled();
-        consoleSpy.mockRestore();
-    });
-
-    it('should be case-insensitive', async () => {
-        const mockData = {
-            data: [{
-                id: 'event-1',
-                slug: 'test',
-                title: 'FEDERAL RESERVE',
-                markets: [{
-                    id: 'market-1',
-                    question: 'Test',
-                    outcomes: '["Yes", "No"]',
-                    outcomePrices: '["0.50", "0.50"]',
-                    clobTokenIds: '["token1", "token2"]',
-                    endDate: '2025-12-31T00:00:00Z',
-                    volume24hr: '10000'
-                }]
-            }]
-        };
-
-        mockedAxios.get.mockResolvedValue(mockData);
-        const resultsLower = await exchange.searchMarkets('federal');
-
-        jest.clearAllMocks();
-        mockedAxios.get.mockResolvedValue(mockData);
-        const resultsUpper = await exchange.searchMarkets('FEDERAL');
-
-        expect(resultsLower.length).toBe(resultsUpper.length);
-    });
-});