pmxt-core 2.39.1 → 2.40.1

package/dist/router/Router.test.js

@@ -1,328 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Router_1 = require("./Router");
-const client_1 = require("./client");
-jest.mock('./client');
-const MockedClient = client_1.PmxtApiClient;
-function mockExchange(name, orderBook) {
-    return {
-        name,
-        fetchOrderBook: orderBook
-            ? jest.fn().mockResolvedValue(orderBook)
-            : jest.fn().mockRejectedValue(new Error('Not found')),
-    };
-}
-describe('Router', () => {
-    let router;
-    let clientInstance;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        MockedClient.mockClear();
-        router = new Router_1.Router({ apiKey: 'test-key' });
-        clientInstance = MockedClient.mock.instances[0];
-    });
-    describe('constructor', () => {
-        it('has name "Router"', () => {
-            expect(router.name).toBe('Router');
-        });
-        it('does not require exchanges option', () => {
-            expect(() => new Router_1.Router({ apiKey: 'key' })).not.toThrow();
-        });
-    });
-    describe('fetchMarketMatches', () => {
-        it('returns matches from the API using marketId', async () => {
-            const mockApiResponse = [
-                {
-                    market: { marketId: 'k1', sourceExchange: 'kalshi', bestBid: 0.60, bestAsk: 0.65 },
-                    relation: 'identity',
-                    confidence: 0.95,
-                    reasoning: 'Same resolution condition.',
-                },
-            ];
-            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: mockApiResponse });
-            const result = await router.fetchMarketMatches({ marketId: 'm1', relation: 'identity' });
-            expect(clientInstance.getMarketMatches).toHaveBeenCalledWith({ marketId: 'm1', relation: 'identity' });
-            expect(result[0].confidence).toBe(0.95);
-            expect(result[0].bestBid).toBe(0.60);
-            expect(result[0].bestAsk).toBe(0.65);
-        });
-        it('accepts slug as identifier', async () => {
-            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: [] });
-            await router.fetchMarketMatches({ slug: 'btc-100k' });
-            expect(clientInstance.getMarketMatches).toHaveBeenCalledWith({ slug: 'btc-100k' });
-        });
-        it('returns empty array when no matches', async () => {
-            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({});
-            const result = await router.fetchMarketMatches({ marketId: 'm1' });
-            expect(result).toEqual([]);
-        });
-    });
-    describe('fetchMatches (deprecated)', () => {
-        it('delegates to fetchMarketMatches and logs deprecation warning', async () => {
-            const mockApiResponse = [
-                {
-                    market: { marketId: 'k1', sourceExchange: 'kalshi', bestBid: 0.60, bestAsk: 0.65 },
-                    relation: 'identity',
-                    confidence: 0.95,
-                    reasoning: 'Same resolution condition.',
-                },
-            ];
-            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: mockApiResponse });
-            const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
-            const result = await router.fetchMatches({ marketId: 'm1' });
-            expect(warnSpy).toHaveBeenCalledWith('[pmxt] fetchMatches is deprecated, use fetchMarketMatches instead');
-            expect(result[0].confidence).toBe(0.95);
-            warnSpy.mockRestore();
-        });
-    });
-    describe('fetchEventMatches', () => {
-        it('returns event matches from the API', async () => {
-            const mockMatches = [
-                { event: { id: 'e2' }, marketMatches: [] },
-            ];
-            clientInstance.getEventMatches = jest.fn().mockResolvedValue({ matches: mockMatches });
-            const result = await router.fetchEventMatches({ eventId: 'e1' });
-            expect(clientInstance.getEventMatches).toHaveBeenCalledWith({ eventId: 'e1' });
-            expect(result).toEqual(mockMatches);
-        });
-    });
-    describe('compareMarketPrices', () => {
-        it('fetches identity matches with includePrices and maps to PriceComparison', async () => {
-            const mockMatches = [
-                {
-                    market: { marketId: 'k1', sourceExchange: 'kalshi', outcomes: [], bestBid: 0.55, bestAsk: 0.62 },
-                    relation: 'identity',
-                    confidence: 0.9,
-                    reasoning: 'Same market.',
-                },
-            ];
-            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: mockMatches });
-            const result = await router.compareMarketPrices({ marketId: 'm1' });
-            expect(clientInstance.getMarketMatches).toHaveBeenCalledWith({
-                marketId: 'm1',
-                relation: 'identity',
-                includePrices: true,
-            });
-            expect(result).toHaveLength(1);
-            expect(result[0].bestBid).toBe(0.55);
-            expect(result[0].bestAsk).toBe(0.62);
-            expect(result[0].venue).toBe('kalshi');
-            expect(result[0].reasoning).toBe('Same market.');
-        });
-    });
-    describe('fetchRelatedMarkets', () => {
-        it('returns only subset/superset matches with reasoning', async () => {
-            const mockMatches = [
-                {
-                    market: { marketId: 'k1', sourceExchange: 'kalshi', bestBid: 0.60, bestAsk: 0.65 },
-                    relation: 'identity',
-                    confidence: 0.95,
-                    reasoning: 'Same.',
-                },
-                {
-                    market: { marketId: 'k2', sourceExchange: 'kalshi', bestBid: 0.40, bestAsk: 0.45 },
-                    relation: 'subset',
-                    confidence: 0.8,
-                    reasoning: 'Narrower market — nomination implies candidacy.',
-                },
-                {
-                    market: { marketId: 'k3', sourceExchange: 'polymarket', bestBid: 0.70, bestAsk: 0.73 },
-                    relation: 'superset',
-                    confidence: 0.7,
-                    reasoning: 'Broader — popular vote does not guarantee election win.',
-                },
-            ];
-            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: mockMatches });
-            const result = await router.fetchRelatedMarkets({ marketId: 'm1' });
-            expect(result).toHaveLength(2);
-            expect(result[0].relation).toBe('subset');
-            expect(result[0].reasoning).toBe('Narrower market — nomination implies candidacy.');
-            expect(result[1].relation).toBe('superset');
-        });
-    });
-    describe('fetchHedges (deprecated)', () => {
-        it('delegates to fetchRelatedMarkets and logs deprecation warning', async () => {
-            const mockMatches = [
-                {
-                    market: { marketId: 'k2', sourceExchange: 'kalshi', bestBid: 0.40, bestAsk: 0.45 },
-                    relation: 'subset',
-                    confidence: 0.8,
-                    reasoning: 'Narrower market.',
-                },
-            ];
-            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: mockMatches });
-            const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
-            const result = await router.fetchHedges({ marketId: 'm1' });
-            expect(warnSpy).toHaveBeenCalledWith('[pmxt] fetchHedges is deprecated, use fetchRelatedMarkets instead');
-            expect(result).toHaveLength(1);
-            warnSpy.mockRestore();
-        });
-    });
-    describe('fetchMarkets', () => {
-        it('returns markets from the API', async () => {
-            const mockMarkets = [{ marketId: 'm1', title: 'BTC' }];
-            clientInstance.searchMarkets = jest.fn().mockResolvedValue(mockMarkets);
-            const result = await router.fetchMarkets({ query: 'bitcoin' });
-            expect(clientInstance.searchMarkets).toHaveBeenCalled();
-            expect(result).toEqual(mockMarkets);
-        });
-    });
-    describe('fetchEvents', () => {
-        it('returns events from the API', async () => {
-            const mockEvents = [{ id: 'e1', title: 'Election' }];
-            clientInstance.searchEvents = jest.fn().mockResolvedValue(mockEvents);
-            const result = await router.fetchEvents({ query: 'election' });
-            expect(clientInstance.searchEvents).toHaveBeenCalled();
-            expect(result).toEqual(mockEvents);
-        });
-    });
-    describe('createOrder', () => {
-        it('throws not implemented error', async () => {
-            await expect(router.createOrder({})).rejects.toThrow('not implemented');
-        });
-    });
-    describe('fetchOrderBook', () => {
-        it('throws when no exchanges are configured', async () => {
-            await expect(router.fetchOrderBook('m1')).rejects.toThrow('Router requires exchange instances for fetchOrderBook');
-        });
-        it('merges orderbooks from matched markets', async () => {
-            const polyBook = {
-                bids: [{ price: 0.45, size: 100 }, { price: 0.44, size: 50 }],
-                asks: [{ price: 0.47, size: 80 }, { price: 0.48, size: 60 }],
-                timestamp: 1000,
-            };
-            const kalshiBook = {
-                bids: [{ price: 0.46, size: 200 }, { price: 0.44, size: 75 }],
-                asks: [{ price: 0.47, size: 120 }, { price: 0.49, size: 90 }],
-                timestamp: 2000,
-            };
-            const polyExchange = mockExchange('polymarket', polyBook);
-            const kalshiExchange = mockExchange('kalshi', kalshiBook);
-            MockedClient.mockClear();
-            const routerWithExchanges = new Router_1.Router({
-                apiKey: 'test-key',
-                exchanges: { polymarket: polyExchange, kalshi: kalshiExchange },
-            });
-            const client = MockedClient.mock.instances[0];
-            // Match API returns kalshi as a match (source is polymarket)
-            client.getMarketMatches = jest.fn().mockResolvedValue({
-                matches: [{
-                        market: {
-                            marketId: 'k1',
-                            sourceExchange: 'kalshi',
-                            outcomes: [
-                                { outcomeId: 'k1-yes', label: 'Yes', price: 0.46 },
-                                { outcomeId: 'k1-no', label: 'No', price: 0.54 },
-                            ],
-                        },
-                        relation: 'identity',
-                        confidence: 0.95,
-                        reasoning: null,
-                    }],
-            });
-            const result = await routerWithExchanges.fetchOrderBook('poly-token-yes', 'yes');
-            // Bids merged: 0.46 (200), 0.45 (100), 0.44 (50+75=125)
-            expect(result.bids).toEqual([
-                { price: 0.46, size: 200 },
-                { price: 0.45, size: 100 },
-                { price: 0.44, size: 125 },
-            ]);
-            // Asks merged: 0.47 (80+120=200), 0.48 (60), 0.49 (90)
-            expect(result.asks).toEqual([
-                { price: 0.47, size: 200 },
-                { price: 0.48, size: 60 },
-                { price: 0.49, size: 90 },
-            ]);
-            // Kalshi was called with the matched outcome ID
-            expect(kalshiExchange.fetchOrderBook).toHaveBeenCalledWith('k1-yes', 'yes');
-            // Polymarket was called with the raw ID (source market)
-            expect(polyExchange.fetchOrderBook).toHaveBeenCalledWith('poly-token-yes', 'yes');
-        });
-        it('returns single exchange book when no matches exist', async () => {
-            const book = {
-                bids: [{ price: 0.50, size: 100 }],
-                asks: [{ price: 0.52, size: 80 }],
-                timestamp: 1000,
-            };
-            const exchange = mockExchange('polymarket', book);
-            MockedClient.mockClear();
-            const routerWithExchanges = new Router_1.Router({
-                apiKey: 'test-key',
-                exchanges: { polymarket: exchange },
-            });
-            const client = MockedClient.mock.instances[0];
-            client.getMarketMatches = jest.fn().mockResolvedValue({ matches: [] });
-            const result = await routerWithExchanges.fetchOrderBook('token-id');
-            expect(result.bids).toEqual([{ price: 0.50, size: 100 }]);
-            expect(result.asks).toEqual([{ price: 0.52, size: 80 }]);
-        });
-        it('defaults side to yes when not specified', async () => {
-            const exchange = mockExchange('kalshi', { bids: [], asks: [], timestamp: 0 });
-            MockedClient.mockClear();
-            const routerWithExchanges = new Router_1.Router({
-                apiKey: 'test-key',
-                exchanges: { kalshi: exchange },
-            });
-            const client = MockedClient.mock.instances[0];
-            client.getMarketMatches = jest.fn().mockResolvedValue({ matches: [] });
-            await routerWithExchanges.fetchOrderBook('ticker');
-            expect(exchange.fetchOrderBook).toHaveBeenCalledWith('ticker', 'yes');
-        });
-        it('skips exchanges that fail and returns partial results', async () => {
-            const book = {
-                bids: [{ price: 0.50, size: 100 }],
-                asks: [{ price: 0.55, size: 50 }],
-                timestamp: 1000,
-            };
-            const goodExchange = mockExchange('kalshi', book);
-            const badExchange = mockExchange('limitless'); // rejects
-            MockedClient.mockClear();
-            const routerWithExchanges = new Router_1.Router({
-                apiKey: 'test-key',
-                exchanges: { kalshi: goodExchange, limitless: badExchange },
-            });
-            const client = MockedClient.mock.instances[0];
-            client.getMarketMatches = jest.fn().mockResolvedValue({ matches: [] });
-            const result = await routerWithExchanges.fetchOrderBook('ticker', 'yes');
-            expect(result.bids).toEqual([{ price: 0.50, size: 100 }]);
-            expect(result.asks).toEqual([{ price: 0.55, size: 50 }]);
-        });
-        it('returns empty orderbook when all exchanges fail', async () => {
-            const badExchange = mockExchange('polymarket');
-            MockedClient.mockClear();
-            const routerWithExchanges = new Router_1.Router({
-                apiKey: 'test-key',
-                exchanges: { polymarket: badExchange },
-            });
-            const client = MockedClient.mock.instances[0];
-            client.getMarketMatches = jest.fn().mockResolvedValue({ matches: [] });
-            const result = await routerWithExchanges.fetchOrderBook('bad-id');
-            expect(result.bids).toEqual([]);
-            expect(result.asks).toEqual([]);
-        });
-    });
-    describe('capabilities', () => {
-        it('reports matching methods as supported', () => {
-            expect(router.has.fetchMarketMatches).toBe(true);
-            expect(router.has.fetchMatches).toBe(true);
-            expect(router.has.fetchEventMatches).toBe(true);
-            expect(router.has.compareMarketPrices).toBe(true);
-            expect(router.has.fetchRelatedMarkets).toBe(true);
-            expect(router.has.fetchMatchedMarkets).toBe(true);
-            expect(router.has.fetchMatchedPrices).toBe(true);
-            expect(router.has.fetchHedges).toBe(true);
-            expect(router.has.fetchArbitrage).toBe(true);
-        });
-        it('reports fetchOrderBook as supported', () => {
-            expect(router.has.fetchOrderBook).toBe(true);
-        });
-        it('reports trading methods as unsupported', () => {
-            expect(router.has.createOrder).toBe(false);
-            expect(router.has.cancelOrder).toBe(false);
-        });
-        it('reports search methods as supported', () => {
-            expect(router.has.fetchMarkets).toBe(true);
-            expect(router.has.fetchEvents).toBe(true);
-        });
-    });
-});

package/dist/router/client.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/router/client.test.js

@@ -1,177 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const axios_1 = __importDefault(require("axios"));
-const client_1 = require("./client");
-const errors_1 = require("../errors");
-jest.mock('axios', () => {
-    const mockInstance = {
-        request: jest.fn(),
-        defaults: { headers: { common: {} } },
-    };
-    const actualAxios = jest.requireActual('axios');
-    const mockAxios = {
-        create: jest.fn(() => mockInstance),
-        isAxiosError: actualAxios.isAxiosError,
-    };
-    return {
-        __esModule: true,
-        ...mockAxios,
-        default: mockAxios,
-    };
-});
-const mockAxiosInstance = axios_1.default.create();
-describe('PmxtApiClient', () => {
-    let client;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockAxiosInstance.request.mockReset();
-        client = new client_1.PmxtApiClient('test-api-key');
-    });
-    it('creates axios instance with Bearer token and default base URL', () => {
-        expect(axios_1.default.create).toHaveBeenCalledWith(expect.objectContaining({
-            baseURL: 'https://api.pmxt.dev',
-            headers: expect.objectContaining({
-                Authorization: 'Bearer test-api-key',
-            }),
-        }));
-    });
-    it('accepts a custom base URL', () => {
-        new client_1.PmxtApiClient('key', 'http://localhost:4111');
-        expect(axios_1.default.create).toHaveBeenCalledWith(expect.objectContaining({
-            baseURL: 'http://localhost:4111',
-        }));
-    });
-    describe('getMarketMatches', () => {
-        it('calls GET /v0/markets/:id/matches with marketId', async () => {
-            const mockData = { data: { market: {}, matches: [{ relation: 'identity' }] } };
-            mockAxiosInstance.request.mockResolvedValue({ data: mockData });
-            const result = await client.getMarketMatches({ marketId: 'abc-123' });
-            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
-                method: 'GET',
-                url: '/v0/markets/abc-123/matches',
-                params: {},
-            });
-            expect(result).toEqual(mockData.data);
-        });
-        it('accepts slug as identifier', async () => {
-            mockAxiosInstance.request.mockResolvedValue({
-                data: { data: { matches: [] } },
-            });
-            await client.getMarketMatches({ slug: 'will-btc-hit-100k' });
-            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
-                method: 'GET',
-                url: '/v0/markets/will-btc-hit-100k/matches',
-                params: {},
-            });
-        });
-        it('accepts url as identifier', async () => {
-            mockAxiosInstance.request.mockResolvedValue({
-                data: { data: { matches: [] } },
-            });
-            await client.getMarketMatches({ url: 'https://polymarket.com/event/btc' });
-            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
-                method: 'GET',
-                url: '/v0/markets/https%3A%2F%2Fpolymarket.com%2Fevent%2Fbtc/matches',
-                params: {},
-            });
-        });
-        it('throws BadRequest when no identifier provided', async () => {
-            await expect(client.getMarketMatches({})).rejects.toThrow(errors_1.BadRequest);
-        });
-        it('passes query params including includePrices', async () => {
-            mockAxiosInstance.request.mockResolvedValue({
-                data: { data: { matches: [] } },
-            });
-            await client.getMarketMatches({
-                marketId: 'abc',
-                relation: 'identity',
-                minConfidence: 0.8,
-                limit: 10,
-                includePrices: true,
-            });
-            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
-                method: 'GET',
-                url: '/v0/markets/abc/matches',
-                params: { relation: 'identity', minConfidence: '0.8', limit: '10', includePrices: 'true' },
-            });
-        });
-    });
-    describe('getEventMatches', () => {
-        it('calls GET /v0/events/:id/matches with eventId', async () => {
-            mockAxiosInstance.request.mockResolvedValue({
-                data: { data: { event: {}, matches: [] } },
-            });
-            await client.getEventMatches({ eventId: 'evt-1' });
-            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
-                method: 'GET',
-                url: '/v0/events/evt-1/matches',
-                params: {},
-            });
-        });
-        it('throws BadRequest when no identifier provided', async () => {
-            await expect(client.getEventMatches({})).rejects.toThrow(errors_1.BadRequest);
-        });
-    });
-    describe('searchMarkets', () => {
-        it('calls GET /v0/markets with query params', async () => {
-            mockAxiosInstance.request.mockResolvedValue({
-                data: { data: [] },
-            });
-            await client.searchMarkets({
-                query: 'bitcoin',
-                sourceExchange: 'polymarket',
-                limit: 20,
-            });
-            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
-                method: 'GET',
-                url: '/v0/markets',
-                params: { q: 'bitcoin', sourceExchange: 'polymarket', limit: '20' },
-            });
-        });
-    });
-    describe('searchEvents', () => {
-        it('calls GET /v0/events with query params', async () => {
-            mockAxiosInstance.request.mockResolvedValue({
-                data: { data: [] },
-            });
-            await client.searchEvents({ query: 'election', category: 'politics' });
-            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
-                method: 'GET',
-                url: '/v0/events',
-                params: { q: 'election', category: 'politics' },
-            });
-        });
-    });
-    describe('error mapping', () => {
-        function makeAxiosError(status, data) {
-            const error = new Error('Request failed');
-            error.isAxiosError = true;
-            error.response = { status, data: data ?? { error: `Error ${status}` }, headers: {} };
-            error.config = {};
-            error.toJSON = () => ({});
-            Object.defineProperty(error, '__CANCEL__', { value: false });
-            return error;
-        }
-        it('maps 401 to AuthenticationError', async () => {
-            mockAxiosInstance.request.mockRejectedValue(makeAxiosError(401, { error: 'Invalid API key' }));
-            await expect(client.getMarketMatches({ marketId: 'x' })).rejects.toThrow(errors_1.AuthenticationError);
-        });
-        it('maps 404 to NotFound', async () => {
-            mockAxiosInstance.request.mockRejectedValue(makeAxiosError(404, { error: 'market not found' }));
-            await expect(client.getMarketMatches({ marketId: 'x' })).rejects.toThrow(errors_1.NotFound);
-        });
-        it('maps 429 to RateLimitExceeded', async () => {
-            const err = makeAxiosError(429, { error: 'Too many requests' });
-            err.response.headers = { 'retry-after': '30' };
-            mockAxiosInstance.request.mockRejectedValue(err);
-            await expect(client.getMarketMatches({ marketId: 'x' })).rejects.toThrow(errors_1.RateLimitExceeded);
-        });
-        it('maps 400 to BadRequest', async () => {
-            mockAxiosInstance.request.mockRejectedValue(makeAxiosError(400, { error: 'Invalid relation' }));
-            await expect(client.getMarketMatches({ marketId: 'x' })).rejects.toThrow(errors_1.BadRequest);
-        });
-    });
-});