pmxt-core 2.39.1 → 2.40.1

package/dist/exchanges/myriad/price.test.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const price_1 = require("./price");
-describe("resolveMyriadPrice", () => {
-    test("divides value by shares", () => {
-        expect((0, price_1.resolveMyriadPrice)({ value: 100, shares: 4 })).toBe(25);
-    });
-    test("treats missing shares as 1", () => {
-        expect((0, price_1.resolveMyriadPrice)({ value: 50 })).toBe(50);
-    });
-    test("treats zero shares as 1 to avoid division by zero", () => {
-        expect((0, price_1.resolveMyriadPrice)({ value: 80, shares: 0 })).toBe(80);
-    });
-    test("treats missing value as 0", () => {
-        expect((0, price_1.resolveMyriadPrice)({ shares: 5 })).toBe(0);
-    });
-});

package/dist/exchanges/polymarket_us/errors.test.d.ts

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

package/dist/exchanges/polymarket_us/errors.test.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("./errors");
-const polymarket_us_1 = require("polymarket-us");
-const errors_2 = require("../../errors");
-describe('PolymarketUSErrorMapper', () => {
-    const mapper = new errors_1.PolymarketUSErrorMapper();
-    test('maps SDK AuthenticationError -> PMXT AuthenticationError', () => {
-        const mapped = mapper.mapError(new polymarket_us_1.AuthenticationError('bad token'));
-        expect(mapped).toBeInstanceOf(errors_2.AuthenticationError);
-        expect(mapped.exchange).toBe('PolymarketUS');
-    });
-    test('maps BadRequestError("Insufficient buying power") -> InsufficientFunds', () => {
-        const mapped = mapper.mapError(new polymarket_us_1.BadRequestError('Insufficient buying power'));
-        expect(mapped).toBeInstanceOf(errors_2.InsufficientFunds);
-    });
-    test('maps BadRequestError("Invalid price tick") -> InvalidOrder', () => {
-        const mapped = mapper.mapError(new polymarket_us_1.BadRequestError('Invalid price tick'));
-        expect(mapped).toBeInstanceOf(errors_2.InvalidOrder);
-    });
-    test('maps BadRequestError("Self-match prevented") -> InvalidOrder', () => {
-        const mapped = mapper.mapError(new polymarket_us_1.BadRequestError('Self-match prevented'));
-        expect(mapped).toBeInstanceOf(errors_2.InvalidOrder);
-    });
-    test('maps NotFoundError("Order not found") -> OrderNotFound', () => {
-        const mapped = mapper.mapError(new polymarket_us_1.NotFoundError('Order not found'));
-        expect(mapped).toBeInstanceOf(errors_2.OrderNotFound);
-    });
-    test('maps NotFoundError("Market not found") -> MarketNotFound', () => {
-        const mapped = mapper.mapError(new polymarket_us_1.NotFoundError('Market not found'));
-        expect(mapped).toBeInstanceOf(errors_2.MarketNotFound);
-    });
-    test('maps RateLimitError -> RateLimitExceeded', () => {
-        const mapped = mapper.mapError(new polymarket_us_1.RateLimitError('slow down'));
-        expect(mapped).toBeInstanceOf(errors_2.RateLimitExceeded);
-    });
-    test('maps InternalServerError -> ExchangeNotAvailable', () => {
-        const mapped = mapper.mapError(new polymarket_us_1.InternalServerError('boom'));
-        expect(mapped).toBeInstanceOf(errors_2.ExchangeNotAvailable);
-    });
-    test('maps generic Error -> generic exchange BaseError', () => {
-        const mapped = mapper.mapError(new Error('something failed'));
-        expect(mapped).toBeInstanceOf(errors_2.BaseError);
-        expect(mapped.exchange).toBe('PolymarketUS');
-        expect(mapped.code).toBe('EXCHANGE_ERROR');
-        expect(mapped.message).toBe('something failed');
-    });
-    test('maps plain object -> generic exchange BaseError', () => {
-        const mapped = mapper.mapError({ message: 'plain object error' });
-        expect(mapped).toBeInstanceOf(errors_2.BaseError);
-        expect(mapped.exchange).toBe('PolymarketUS');
-        expect(mapped.message).toBe('plain object error');
-    });
-});

package/dist/exchanges/polymarket_us/index.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Integration tests for PolymarketUSExchange.
- *
- * The `polymarket-us` SDK is fully mocked here so the tests run without
- * touching the network. Each test instantiates a fresh exchange (and
- * therefore a fresh mock client) so per-test mock setup is independent.
- */
-export {};

package/dist/exchanges/polymarket_us/index.test.js

@@ -1,237 +0,0 @@
-"use strict";
-/**
- * Integration tests for PolymarketUSExchange.
- *
- * The `polymarket-us` SDK is fully mocked here so the tests run without
- * touching the network. Each test instantiates a fresh exchange (and
- * therefore a fresh mock client) so per-test mock setup is independent.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-jest.mock('polymarket-us', () => {
-    class PolymarketUSError extends Error {
-    }
-    class APIError extends PolymarketUSError {
-        status;
-        constructor(status, message) {
-            super(message);
-            this.status = status;
-        }
-    }
-    class AuthenticationError extends APIError {
-        constructor(m = 'auth') { super(401, m); }
-    }
-    class BadRequestError extends APIError {
-        constructor(m = 'bad request') { super(400, m); }
-    }
-    class NotFoundError extends APIError {
-        constructor(m = 'not found') { super(404, m); }
-    }
-    class RateLimitError extends APIError {
-        constructor(m = 'rate limit') { super(429, m); }
-    }
-    class InternalServerError extends APIError {
-        constructor(m = 'server') { super(500, m); }
-    }
-    const PolymarketUS = jest.fn().mockImplementation(() => ({
-        markets: {
-            list: jest.fn(),
-            book: jest.fn(),
-            retrieveBySlug: jest.fn(),
-        },
-        events: {
-            list: jest.fn(),
-            retrieveBySlug: jest.fn(),
-        },
-        orders: {
-            list: jest.fn(),
-            retrieve: jest.fn(),
-            create: jest.fn(),
-            cancel: jest.fn(),
-        },
-        portfolio: {
-            positions: jest.fn(),
-            activities: jest.fn(),
-        },
-        account: {
-            balances: jest.fn(),
-        },
-    }));
-    return {
-        PolymarketUS,
-        PolymarketUSError,
-        APIError,
-        AuthenticationError,
-        BadRequestError,
-        NotFoundError,
-        RateLimitError,
-        InternalServerError,
-    };
-});
-const index_1 = require("./index");
-const errors_1 = require("../../errors");
-const polymarket_us_1 = require("polymarket-us");
-const CREDS = { apiKey: 'k1', privateKey: 's1' };
-function getClient(exchange) {
-    return exchange.client;
-}
-function makeMarketDetail(slug = 'btc-100k') {
-    return {
-        id: 1,
-        slug,
-        title: `Market ${slug}`,
-        outcome: 'binary',
-        description: 'desc',
-        active: true,
-        closed: false,
-        liquidity: 100,
-        volume: 1000,
-        eventSlug: 'evt-1',
-    };
-}
-function makeSdkOrder(overrides = {}) {
-    return {
-        id: 'order-1',
-        marketSlug: 'btc-100k',
-        side: 'ORDER_SIDE_BUY',
-        type: 'ORDER_TYPE_LIMIT',
-        price: { value: '0.55', currency: 'USD' },
-        quantity: 10,
-        cumQuantity: 0,
-        leavesQuantity: 10,
-        tif: 'TIME_IN_FORCE_GOOD_TILL_CANCEL',
-        intent: 'ORDER_INTENT_BUY_LONG',
-        state: 'ORDER_STATE_NEW',
-        ...overrides,
-    };
-}
-describe('PolymarketUSExchange', () => {
-    describe('construction', () => {
-        it('constructs without credentials but rejects auth-required calls', async () => {
-            const ex = new index_1.PolymarketUSExchange();
-            await expect(ex.fetchBalance()).rejects.toBeInstanceOf(errors_1.AuthenticationError);
-        });
-        it('constructs with credentials and exposes the unified name', () => {
-            const ex = new index_1.PolymarketUSExchange(CREDS);
-            expect(ex.name).toBe('PolymarketUS');
-        });
-    });
-    describe('fetchMarkets', () => {
-        it('returns normalized markets from markets.list', async () => {
-            const ex = new index_1.PolymarketUSExchange(CREDS);
-            const client = getClient(ex);
-            client.markets.list.mockResolvedValue({
-                markets: [makeMarketDetail('btc-100k'), makeMarketDetail('eth-5k')],
-            });
-            const result = await ex.fetchMarkets();
-            expect(client.markets.list).toHaveBeenCalledWith({
-                active: true,
-                limit: 250,
-                offset: 0,
-            });
-            expect(result).toHaveLength(2);
-            expect(result[0].marketId).toBe('btc-100k');
-            expect(result[1].marketId).toBe('eth-5k');
-        });
-        it('uses retrieveBySlug for direct slug lookup', async () => {
-            const ex = new index_1.PolymarketUSExchange(CREDS);
-            const client = getClient(ex);
-            client.markets.retrieveBySlug.mockResolvedValue({
-                market: makeMarketDetail('btc-100k'),
-            });
-            const result = await ex.fetchMarkets({ slug: 'btc-100k' });
-            expect(client.markets.retrieveBySlug).toHaveBeenCalledWith('btc-100k');
-            expect(result).toHaveLength(1);
-            expect(result[0].marketId).toBe('btc-100k');
-        });
-    });
-    describe('fetchOrderBook', () => {
-        it('normalizes a market book', async () => {
-            const ex = new index_1.PolymarketUSExchange(CREDS);
-            const client = getClient(ex);
-            client.markets.book.mockResolvedValue({
-                marketSlug: 'btc-100k',
-                bids: [{ px: { value: '0.55', currency: 'USD' }, qty: '10' }],
-                offers: [{ px: { value: '0.57', currency: 'USD' }, qty: '5' }],
-                state: 'MARKET_STATE_OPEN',
-                transactTime: '2024-01-01T00:00:00Z',
-            });
-            const book = await ex.fetchOrderBook('btc-100k');
-            expect(client.markets.book).toHaveBeenCalledWith('btc-100k');
-            expect(book.bids).toEqual([{ price: 0.55, size: 10 }]);
-            expect(book.asks).toEqual([{ price: 0.57, size: 5 }]);
-        });
-    });
-    describe('buildOrder', () => {
-        it('builds a BUY LONG limit order at the user price', async () => {
-            const ex = new index_1.PolymarketUSExchange(CREDS);
-            const built = await ex.buildOrder({
-                marketId: 'btc-100k',
-                outcomeId: 'btc-100k:long',
-                side: 'buy',
-                type: 'limit',
-                amount: 10,
-                price: 0.55,
-            });
-            const raw = built.raw;
-            expect(raw.intent).toBe('ORDER_INTENT_BUY_LONG');
-            expect(raw.type).toBe('ORDER_TYPE_LIMIT');
-            expect(raw.marketSlug).toBe('btc-100k');
-            expect(raw.quantity).toBe(10);
-            expect(raw.price.value).toBe('0.550');
-        });
-        it('builds a BUY SHORT limit order using long-side price conversion', async () => {
-            const ex = new index_1.PolymarketUSExchange(CREDS);
-            const built = await ex.buildOrder({
-                marketId: 'btc-100k',
-                outcomeId: 'btc-100k:short',
-                side: 'buy',
-                type: 'limit',
-                amount: 10,
-                price: 0.40,
-            });
-            const raw = built.raw;
-            expect(raw.intent).toBe('ORDER_INTENT_BUY_SHORT');
-            expect(raw.price.value).toBe('0.600');
-        });
-    });
-    describe('cancelOrder', () => {
-        it('uses cached marketSlug when available', async () => {
-            const ex = new index_1.PolymarketUSExchange(CREDS);
-            const client = getClient(ex);
-            // Pre-populate cache by listing open orders
-            client.orders.list.mockResolvedValue({
-                orders: [makeSdkOrder({ id: 'order-123', marketSlug: 'btc-100k' })],
-            });
-            await ex.fetchOpenOrders();
-            client.orders.cancel.mockResolvedValue(undefined);
-            client.orders.retrieve.mockResolvedValue({
-                order: makeSdkOrder({ id: 'order-123', state: 'ORDER_STATE_CANCELED' }),
-            });
-            await ex.cancelOrder('order-123');
-            expect(client.orders.cancel).toHaveBeenCalledWith('order-123', {
-                marketSlug: 'btc-100k',
-            });
-        });
-        it('fetches the order first when slug is not cached', async () => {
-            const ex = new index_1.PolymarketUSExchange(CREDS);
-            const client = getClient(ex);
-            client.orders.retrieve.mockResolvedValue({
-                order: makeSdkOrder({ id: 'order-456', marketSlug: 'eth-5k' }),
-            });
-            client.orders.cancel.mockResolvedValue(undefined);
-            await ex.cancelOrder('order-456');
-            expect(client.orders.retrieve).toHaveBeenCalledWith('order-456');
-            expect(client.orders.cancel).toHaveBeenCalledWith('order-456', {
-                marketSlug: 'eth-5k',
-            });
-        });
-    });
-    describe('error mapping', () => {
-        it('translates SDK AuthenticationError into PMXT AuthenticationError', async () => {
-            const ex = new index_1.PolymarketUSExchange(CREDS);
-            const client = getClient(ex);
-            client.account.balances.mockRejectedValue(new polymarket_us_1.AuthenticationError('bad creds'));
-            await expect(ex.fetchBalance()).rejects.toBeInstanceOf(errors_1.AuthenticationError);
-        });
-    });
-});

package/dist/exchanges/polymarket_us/normalizer.test.d.ts

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

package/dist/exchanges/polymarket_us/normalizer.test.js

@@ -1,224 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// Mock the price helpers so this test does not depend on price.ts being
-// implemented yet (it is created in parallel by another agent).
-jest.mock('./price', () => ({
-    fromAmount: (a) => a ? parseFloat(a.value) : 0,
-    fromLongSidePrice: (intent, longPrice) => intent.endsWith('SHORT') ? 1 - longPrice : longPrice,
-    toAmount: (p) => ({ value: p.toFixed(2), currency: 'USD' }),
-}));
-const normalizer_1 = require("./normalizer");
-function makeOrder(overrides = {}) {
-    return {
-        id: 'order-1',
-        marketSlug: 'btc-100k',
-        side: 'ORDER_SIDE_BUY',
-        type: 'ORDER_TYPE_LIMIT',
-        price: { value: '0.55', currency: 'USD' },
-        quantity: 10,
-        cumQuantity: 0,
-        leavesQuantity: 10,
-        tif: 'TIME_IN_FORCE_GOOD_TILL_CANCEL',
-        intent: 'ORDER_INTENT_BUY_LONG',
-        state: 'ORDER_STATE_NEW',
-        createTime: '2026-01-01T00:00:00.000Z',
-        ...overrides,
-    };
-}
-describe('PolymarketUSNormalizer', () => {
-    const normalizer = new normalizer_1.PolymarketUSNormalizer();
-    describe('normalizeMarket', () => {
-        it('uses the slug as marketId and synthesizes long/short outcomes', () => {
-            const detail = {
-                id: 1,
-                slug: 'btc-100k',
-                title: 'BTC reaches $100k',
-                outcome: 'yes',
-                description: 'Will BTC hit 100k by year end?',
-                active: true,
-                closed: false,
-                liquidity: 5000,
-                volume: 12345,
-                eventSlug: 'btc-events',
-            };
-            const um = normalizer.normalizeMarket(detail);
-            expect(um.marketId).toBe('btc-100k');
-            expect(um.slug).toBe('btc-100k');
-            expect(um.title).toBe('BTC reaches $100k');
-            expect(um.description).toBe('Will BTC hit 100k by year end?');
-            expect(um.outcomes).toHaveLength(2);
-            expect(um.outcomes[0].outcomeId).toBe('btc-100k:long');
-            expect(um.outcomes[0].label).toBe('long');
-            expect(um.outcomes[1].outcomeId).toBe('btc-100k:short');
-            expect(um.outcomes[1].label).toBe('short');
-            expect(um.liquidity).toBe(5000);
-            expect(um.volume).toBe(12345);
-        });
-        it('populates outcome prices from marketSides[].price and tickSize from orderPriceMinTickSize', () => {
-            const detail = {
-                slug: 'nfl-sf-at-kc',
-                question: 'SF at KC',
-                marketSides: [
-                    { description: 'Kansas City Chiefs', long: true, price: '0.864' },
-                    { description: 'San Francisco 49ers', long: false, price: '0.136' },
-                ],
-                orderPriceMinTickSize: 0.001,
-            };
-            const um = normalizer.normalizeMarket(detail);
-            expect(um.outcomes[0].price).toBeCloseTo(0.864);
-            expect(um.outcomes[0].metadata?.sideDescription).toBe('Kansas City Chiefs');
-            expect(um.outcomes[1].price).toBeCloseTo(0.136);
-            expect(um.outcomes[1].metadata?.sideDescription).toBe('San Francisco 49ers');
-            expect(um.tickSize).toBe(0.001);
-        });
-        it('derives the short-side price from 1 - longPrice when only the long side is quoted', () => {
-            const detail = {
-                slug: 'btc-100k',
-                question: 'BTC 100k',
-                marketSides: [
-                    { long: true, price: '0.72' },
-                    { long: false },
-                ],
-            };
-            const um = normalizer.normalizeMarket(detail);
-            expect(um.outcomes[0].price).toBeCloseTo(0.72);
-            expect(um.outcomes[1].price).toBeCloseTo(0.28);
-        });
-        it('falls back to outcomePrices[] when marketSides is missing', () => {
-            const detail = {
-                slug: 'eth-5k',
-                question: 'ETH 5k',
-                outcomePrices: ['0.30', '0.70'],
-            };
-            const um = normalizer.normalizeMarket(detail);
-            expect(um.outcomes[0].price).toBeCloseTo(0.30);
-            expect(um.outcomes[1].price).toBeCloseTo(0.70);
-        });
-    });
-    describe('normalizeOrderBook', () => {
-        it('preserves bid/offer levels with parsed numeric prices', () => {
-            const book = {
-                marketSlug: 'btc-100k',
-                bids: [
-                    { px: { value: '0.55', currency: 'USD' }, qty: '100' },
-                    { px: { value: '0.54', currency: 'USD' }, qty: '50' },
-                ],
-                offers: [
-                    { px: { value: '0.56', currency: 'USD' }, qty: '75' },
-                    { px: { value: '0.57', currency: 'USD' }, qty: '25' },
-                ],
-                state: 'MARKET_STATE_OPEN',
-            };
-            const ob = normalizer.normalizeOrderBook(book, 'btc-100k');
-            expect(ob.bids).toEqual([
-                { price: 0.55, size: 100 },
-                { price: 0.54, size: 50 },
-            ]);
-            expect(ob.asks).toEqual([
-                { price: 0.56, size: 75 },
-                { price: 0.57, size: 25 },
-            ]);
-            expect(typeof ob.timestamp).toBe('number');
-        });
-    });
-    describe('normalizeOrder - intent mapping', () => {
-        const cases = [
-            { intent: 'ORDER_INTENT_BUY_LONG', expectedSide: 'buy', expectedOutcomeSuffix: ':long' },
-            { intent: 'ORDER_INTENT_SELL_LONG', expectedSide: 'sell', expectedOutcomeSuffix: ':long' },
-            { intent: 'ORDER_INTENT_BUY_SHORT', expectedSide: 'buy', expectedOutcomeSuffix: ':short' },
-            { intent: 'ORDER_INTENT_SELL_SHORT', expectedSide: 'sell', expectedOutcomeSuffix: ':short' },
-        ];
-        for (const { intent, expectedSide, expectedOutcomeSuffix } of cases) {
-            it(`maps ${intent} to side=${expectedSide} and outcomeId ending in ${expectedOutcomeSuffix}`, () => {
-                const order = normalizer.normalizeOrder(makeOrder({ intent }));
-                expect(order.side).toBe(expectedSide);
-                expect(order.outcomeId.endsWith(expectedOutcomeSuffix)).toBe(true);
-                expect(order.marketId).toBe('btc-100k');
-            });
-        }
-        it('keeps long-side price unchanged for BUY_LONG', () => {
-            const order = normalizer.normalizeOrder(makeOrder({
-                intent: 'ORDER_INTENT_BUY_LONG',
-                price: { value: '0.60', currency: 'USD' },
-            }));
-            expect(order.price).toBeCloseTo(0.60);
-        });
-        it('flips long-side price to short-side for BUY_SHORT', () => {
-            const order = normalizer.normalizeOrder(makeOrder({
-                intent: 'ORDER_INTENT_BUY_SHORT',
-                price: { value: '0.60', currency: 'USD' },
-            }));
-            expect(order.price).toBeCloseTo(0.40);
-        });
-    });
-    describe('normalizeOrder - state mapping', () => {
-        const cases = [
-            { state: 'ORDER_STATE_NEW', expected: 'open' },
-            { state: 'ORDER_STATE_PARTIALLY_FILLED', expected: 'open' },
-            { state: 'ORDER_STATE_FILLED', expected: 'filled' },
-            { state: 'ORDER_STATE_CANCELED', expected: 'cancelled' },
-            { state: 'ORDER_STATE_REJECTED', expected: 'rejected' },
-            { state: 'ORDER_STATE_EXPIRED', expected: 'cancelled' },
-        ];
-        for (const { state, expected } of cases) {
-            it(`maps ${state} to ${expected}`, () => {
-                const order = normalizer.normalizeOrder(makeOrder({ state }));
-                expect(order.status).toBe(expected);
-            });
-        }
-    });
-    describe('normalizePositions', () => {
-        it('maps positive netPosition to long and negative to short with absolute sizes', () => {
-            const positions = {
-                'btc-100k': {
-                    netPosition: '15',
-                    qtyBought: '20',
-                    qtySold: '5',
-                    cost: { value: '7.50', currency: 'USD' },
-                    realized: { value: '0.00', currency: 'USD' },
-                    bodPosition: '0',
-                    expired: false,
-                },
-                'eth-5k': {
-                    netPosition: '-8',
-                    qtyBought: '2',
-                    qtySold: '10',
-                    cost: { value: '4.00', currency: 'USD' },
-                    realized: { value: '1.25', currency: 'USD' },
-                    bodPosition: '0',
-                    expired: false,
-                },
-            };
-            const result = normalizer.normalizePositions(positions);
-            expect(result).toHaveLength(2);
-            const btc = result.find(p => p.marketId === 'btc-100k');
-            expect(btc.outcomeId).toBe('btc-100k:long');
-            expect(btc.outcomeLabel).toBe('long');
-            expect(btc.size).toBe(15);
-            expect(btc.entryPrice).toBeCloseTo(0.5);
-            const eth = result.find(p => p.marketId === 'eth-5k');
-            expect(eth.outcomeId).toBe('eth-5k:short');
-            expect(eth.outcomeLabel).toBe('short');
-            expect(eth.size).toBe(8);
-            expect(eth.entryPrice).toBeCloseTo(0.5);
-            expect(eth.realizedPnL).toBeCloseTo(1.25);
-        });
-    });
-    describe('normalizeBalance', () => {
-        it('maps current/buyingPower to total/available/locked', () => {
-            const balance = {
-                currentBalance: 1000,
-                currency: 'USD',
-                buyingPower: 800,
-            };
-            const result = normalizer.normalizeBalance(balance);
-            expect(result).toHaveLength(1);
-            expect(result[0]).toEqual({
-                currency: 'USD',
-                total: 1000,
-                available: 800,
-                locked: 200,
-            });
-        });
-    });
-});

package/dist/exchanges/polymarket_us/price.test.d.ts

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