pmxt-core 2.37.10 → 2.37.12

package/dist/router/Router.js

@@ -3,11 +3,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Router = void 0;
 const BaseExchange_1 = require("../BaseExchange");
 const client_1 = require("./client");
+// ---------------------------------------------------------------------------
+// Orderbook merge utilities
+// ---------------------------------------------------------------------------
+function findOutcomeForSide(market, side) {
+    return market.outcomes.find((o) => o.label.toLowerCase() === side)
+        ?? market.outcomes[side === 'yes' ? 0 : 1];
+}
+function mergeLevels(levels) {
+    const byPrice = new Map();
+    for (const level of levels) {
+        byPrice.set(level.price, (byPrice.get(level.price) ?? 0) + level.size);
+    }
+    return Array.from(byPrice.entries()).map(([price, size]) => ({ price, size }));
+}
+function mergeOrderBooks(books) {
+    const allBids = books.flatMap((b) => b.bids);
+    const allAsks = books.flatMap((b) => b.asks);
+    return {
+        bids: mergeLevels(allBids).sort((a, b) => b.price - a.price),
+        asks: mergeLevels(allAsks).sort((a, b) => a.price - b.price),
+        timestamp: Date.now(),
+    };
+}
+// ---------------------------------------------------------------------------
 class Router extends BaseExchange_1.PredictionMarketExchange {
     client;
+    exchanges;
     constructor(options) {
         super({ apiKey: options.apiKey });
         this.client = new client_1.PmxtApiClient(options.apiKey, options.baseUrl);
+        this.exchanges = options.exchanges ?? {};
         this.rateLimit = 100;
     }
     get name() {
@@ -36,6 +62,45 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
         return response ?? [];
     }
     // -----------------------------------------------------------------------
+    // Unified orderbook (cross-exchange merge)
+    // -----------------------------------------------------------------------
+    async fetchOrderBook(id, side) {
+        const exchangeNames = Object.keys(this.exchanges);
+        if (exchangeNames.length === 0) {
+            throw new Error('Router requires exchange instances for fetchOrderBook. Pass exchanges in RouterOptions.');
+        }
+        const resolvedSide = side ?? 'yes';
+        // Find identity matches across venues
+        const matches = await this.fetchMarketMatches({
+            marketId: id,
+            relation: 'identity',
+        });
+        const fetchPromises = [];
+        const matchedVenues = new Set(matches.map((m) => m.market.sourceExchange).filter(Boolean));
+        // Fetch from matched markets (we know their exchange + outcome IDs)
+        for (const match of matches) {
+            const venueName = match.market.sourceExchange ?? '';
+            const exchange = this.exchanges[venueName];
+            if (!exchange)
+                continue;
+            const outcome = findOutcomeForSide(match.market, resolvedSide);
+            if (!outcome)
+                continue;
+            fetchPromises.push(exchange.fetchOrderBook(outcome.outcomeId, resolvedSide).catch(() => null));
+        }
+        // Fetch the source market's orderbook (try remaining exchanges with the raw ID)
+        for (const [name, exchange] of Object.entries(this.exchanges)) {
+            if (matchedVenues.has(name))
+                continue;
+            fetchPromises.push(exchange.fetchOrderBook(id, resolvedSide).catch(() => null));
+        }
+        const books = (await Promise.all(fetchPromises)).filter((b) => b !== null);
+        if (books.length === 0) {
+            return { bids: [], asks: [], timestamp: Date.now() };
+        }
+        return mergeOrderBooks(books);
+    }
+    // -----------------------------------------------------------------------
     // Cross-exchange market matches
     // -----------------------------------------------------------------------
     async fetchMarketMatches(params = {}) {

package/dist/router/Router.test.js

@@ -4,6 +4,14 @@ 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;
@@ -173,6 +181,126 @@ describe('Router', () => {
             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);
@@ -185,10 +313,12 @@ describe('Router', () => {
             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);
-            expect(router.has.fetchOrderBook).toBe(false);
         });
         it('reports search methods as supported', () => {
             expect(router.has.fetchMarkets).toBe(true);

package/dist/router/types.d.ts

@@ -1,8 +1,11 @@
+import type { PredictionMarketExchange } from '../BaseExchange';
 import type { UnifiedMarket, UnifiedEvent } from '../types';
 export type MatchRelation = 'identity' | 'subset' | 'superset' | 'overlap' | 'disjoint';
 export interface RouterOptions {
     apiKey: string;
     baseUrl?: string;
+    /** Exchange instances for cross-venue orderbook aggregation. Keyed by exchange name (e.g. 'polymarket', 'kalshi'). */
+    exchanges?: Record<string, PredictionMarketExchange>;
 }
 export interface MatchResult {
     market: UnifiedMarket;

package/dist/server/method-verbs.json

@@ -384,6 +384,16 @@
       }
     ]
   },
+  "testDummyMethod": {
+    "verb": "post",
+    "args": [
+      {
+        "name": "param",
+        "kind": "string",
+        "optional": true
+      }
+    ]
+  },
   "close": {
     "verb": "post",
     "args": []

package/dist/server/openapi.yaml

@@ -1527,6 +1527,39 @@ paths:
               schema:
                 $ref: '#/components/schemas/BaseResponse'
       description: Stop watching a previously registered wallet address and release its resource updates.
+  '/api/{exchange}/testDummyMethod':
+    post:
+      summary: Test Dummy Method
+      operationId: testDummyMethod
+      parameters:
+        - $ref: '#/components/parameters/ExchangeParam'
+      requestBody:
+        content:
+          application/json:
+            schema:
+              title: TestDummyMethodRequest
+              type: object
+              properties:
+                args:
+                  type: array
+                  maxItems: 1
+                  items:
+                    type: string
+                credentials:
+                  $ref: '#/components/schemas/ExchangeCredentials'
+      responses:
+        '200':
+          description: Test Dummy Method response
+          content:
+            application/json:
+              schema:
+                allOf:
+                  - $ref: '#/components/schemas/BaseResponse'
+                  - type: object
+                    properties:
+                      data:
+                        type: string
+      description: Test method for auto-generation verification.
   '/api/{exchange}/close':
     post:
       summary: Close
@@ -1553,9 +1586,6 @@ paths:
             application/json:
               schema:
                 $ref: '#/components/schemas/BaseResponse'
-      description: >-
-        Close all WebSocket connections and clean up resources. Call this when you're done streaming to properly release
-        connections.
   '/api/{exchange}/fetchMarketMatches':
     get:
       summary: Market Matches
@@ -3442,6 +3472,8 @@ components:
           description: The address funding the trades (defaults to signer address)
         walletAddress:
           type: string
+        baseUrl:
+          type: string
 x-sdk-constructors:
   polymarket:
     className: Polymarket

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxt-core",
-  "version": "2.37.10",
+  "version": "2.37.12",
   "description": "pmxt is a unified prediction market data API. The ccxt for prediction markets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,8 +29,8 @@
     "test": "jest -c jest.config.js",
     "server": "tsx watch src/server/index.ts",
     "server:prod": "node dist/server/index.js",
-    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.37.10,library=urllib3",
-    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.37.10,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
+    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.37.12,library=urllib3",
+    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.37.12,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
     "fetch:openapi": "node scripts/fetch-openapi-specs.js",
     "extract:jsdoc": "node ../scripts/extract-jsdoc.js",
     "generate:docs": "npm run extract:jsdoc && node ../scripts/generate-api-docs.js",