pmxt-core 2.35.7 → 2.35.9

package/dist/exchanges/probable/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.probableApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-04-27T07:41:03.268Z
+ * Generated at: 2026-04-27T12:43:03.895Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.probableApiSpec = {

package/dist/router/Router.d.ts

@@ -1,19 +1,32 @@
 import { PredictionMarketExchange, type MarketFetchParams, type EventFetchParams } from '../BaseExchange';
 import type { UnifiedMarket, UnifiedEvent } from '../types';
-import type { RouterOptions, MatchResult, EventMatchResult, PriceComparison, ArbitrageOpportunity, FetchMarketMatchesParams, FetchMatchesParams, FetchEventMatchesParams, FetchArbitrageParams } from './types';
+import type { RouterOptions, MatchResult, EventMatchResult, PriceComparison, ArbitrageOpportunity, MatchedMarketPair, MatchedPricePair, FetchMarketMatchesParams, FetchMatchesParams, FetchEventMatchesParams, FetchArbitrageParams, FetchMatchedMarketsParams, FetchMatchedPricesParams } from './types';
 export declare class Router extends PredictionMarketExchange {
     private readonly client;
     constructor(options: RouterOptions);
     get name(): string;
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params?: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchMarketMatches(params: FetchMarketMatchesParams): Promise<MatchResult[]>;
+    fetchMarketMatches(params?: FetchMarketMatchesParams): Promise<MatchResult[]>;
+    /**
+     * Browse mode: fetch all matched market pairs from the catalog.
+     * Each result includes sourceMarket (one side) and market (the other).
+     */
+    private fetchMarketMatchesBrowse;
     /** @deprecated Use {@link fetchMarketMatches} instead. */
     fetchMatches(params: FetchMatchesParams): Promise<MatchResult[]>;
-    fetchEventMatches(params: FetchEventMatchesParams): Promise<EventMatchResult[]>;
+    fetchEventMatches(params?: FetchEventMatchesParams): Promise<EventMatchResult[]>;
     compareMarketPrices(params: FetchMarketMatchesParams): Promise<PriceComparison[]>;
+    fetchRelatedMarkets(params: FetchMarketMatchesParams): Promise<PriceComparison[]>;
+    /** @deprecated Use {@link fetchRelatedMarkets} instead. */
     fetchHedges(params: FetchMarketMatchesParams): Promise<PriceComparison[]>;
+    /** @deprecated Use {@link fetchMarketMatches} without a marketId instead. */
+    fetchMatchedMarkets(params?: FetchMatchedMarketsParams): Promise<MatchedMarketPair[]>;
+    /** @deprecated Use {@link fetchMatchedMarkets} instead. */
+    fetchMatchedPrices(params?: FetchMatchedPricesParams): Promise<MatchedPricePair[]>;
+    /** @deprecated Use {@link fetchMatchedMarkets} instead. */
     fetchArbitrage(params?: FetchArbitrageParams): Promise<ArbitrageOpportunity[]>;
+    private fetchArbitrageInternal;
     /**
      * Bulk arbitrage via `GET /v0/arbitrage`. One round-trip.
      */

package/dist/router/Router.js

@@ -38,10 +38,17 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
     // -----------------------------------------------------------------------
     // Cross-exchange market matches
     // -----------------------------------------------------------------------
-    async fetchMarketMatches(params) {
+    async fetchMarketMatches(params = {}) {
         if (params.market && !params.marketId) {
             params = { ...params, marketId: params.market.marketId };
         }
+        // Browse mode: no specific market identifier → return all matches
+        // from the catalog, with both sides of each pair.
+        const hasIdentifier = params.marketId || params.slug || params.url;
+        if (!hasIdentifier) {
+            return this.fetchMarketMatchesBrowse(params);
+        }
+        // Lookup mode: find matches for a specific market.
         const response = await this.client.getMarketMatches(params);
         const matches = response.matches ?? [];
         return matches.map((m) => ({
@@ -53,6 +60,28 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
             bestAsk: m.market?.bestAsk ?? null,
         }));
     }
+    /**
+     * Browse mode: fetch all matched market pairs from the catalog.
+     * Each result includes sourceMarket (one side) and market (the other).
+     */
+    async fetchMarketMatchesBrowse(params) {
+        const bulkParams = {
+            minSpread: params.minDifference,
+            category: params.category,
+            limit: params.limit,
+            relations: params.relation ? [params.relation] : undefined,
+        };
+        const pairs = await this.fetchArbitrageInternal(bulkParams);
+        return pairs.map((opp) => ({
+            sourceMarket: opp.marketA,
+            market: opp.marketB,
+            relation: opp.relation ?? 'identity',
+            confidence: opp.confidence ?? 0,
+            reasoning: opp.reasoning ?? null,
+            bestBid: opp.sellPrice ?? null,
+            bestAsk: null,
+        }));
+    }
     /** @deprecated Use {@link fetchMarketMatches} instead. */
     async fetchMatches(params) {
         console.warn('[pmxt] fetchMatches is deprecated, use fetchMarketMatches instead');
@@ -61,7 +90,7 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
     // -----------------------------------------------------------------------
     // Cross-exchange event matches
     // -----------------------------------------------------------------------
-    async fetchEventMatches(params) {
+    async fetchEventMatches(params = {}) {
         if (params.event && !params.eventId) {
             params = { ...params, eventId: params.event.id };
         }
@@ -91,9 +120,9 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
         }));
     }
     // -----------------------------------------------------------------------
-    // Hedging: subset/superset matches with live prices
+    // Related markets: subset/superset matches with live prices
     // -----------------------------------------------------------------------
-    async fetchHedges(params) {
+    async fetchRelatedMarkets(params) {
         if (params.market && !params.marketId) {
             params = { ...params, marketId: params.market.marketId };
         }
@@ -113,10 +142,51 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
             venue: m.market.sourceExchange ?? '',
         }));
     }
+    /** @deprecated Use {@link fetchRelatedMarkets} instead. */
+    async fetchHedges(params) {
+        console.warn('[pmxt] fetchHedges is deprecated, use fetchRelatedMarkets instead');
+        return this.fetchRelatedMarkets(params);
+    }
     // -----------------------------------------------------------------------
-    // Arbitrage: scan matches for price spreads
+    // Matched markets (deprecated — use fetchMarketMatches without a
+    // marketId for browse mode instead)
     // -----------------------------------------------------------------------
+    /** @deprecated Use {@link fetchMarketMatches} without a marketId instead. */
+    async fetchMatchedMarkets(params) {
+        // Convert params: minDifference -> minSpread for internal use
+        const legacyParams = params
+            ? {
+                minSpread: params.minDifference,
+                category: params.category,
+                limit: params.limit,
+                relations: params.relations,
+            }
+            : undefined;
+        const legacy = await this.fetchArbitrageInternal(legacyParams);
+        return legacy.map((opp) => ({
+            marketA: opp.marketA,
+            marketB: opp.marketB,
+            priceDifference: opp.spread,
+            venueA: opp.buyVenue,
+            venueB: opp.sellVenue,
+            priceA: opp.buyPrice,
+            priceB: opp.sellPrice,
+            relation: opp.relation,
+            confidence: opp.confidence,
+            reasoning: opp.reasoning ?? null,
+        }));
+    }
+    /** @deprecated Use {@link fetchMatchedMarkets} instead. */
+    async fetchMatchedPrices(params) {
+        console.warn('[pmxt] fetchMatchedPrices is deprecated, use fetchMatchedMarkets instead');
+        return this.fetchMatchedMarkets(params);
+    }
+    /** @deprecated Use {@link fetchMatchedMarkets} instead. */
     async fetchArbitrage(params) {
+        console.warn('[pmxt] fetchArbitrage is deprecated, use fetchMatchedPrices instead');
+        return this.fetchArbitrageInternal(params);
+    }
+    async fetchArbitrageInternal(params) {
         // Try the dedicated bulk endpoint first (single DB query).
         try {
             return await this.fetchArbitrageBulk(params);

package/dist/router/Router.test.js

@@ -102,7 +102,7 @@ describe('Router', () => {
             expect(result[0].reasoning).toBe('Same market.');
         });
     });
-    describe('fetchHedges', () => {
+    describe('fetchRelatedMarkets', () => {
         it('returns only subset/superset matches with reasoning', async () => {
             const mockMatches = [
                 {
@@ -125,13 +125,31 @@ describe('Router', () => {
                 },
             ];
             clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: mockMatches });
-            const result = await router.fetchHedges({ marketId: 'm1' });
+            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' }];
@@ -161,6 +179,9 @@ describe('Router', () => {
             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);
         });

package/dist/router/types.d.ts

@@ -6,6 +6,8 @@ export interface RouterOptions {
 }
 export interface MatchResult {
     market: UnifiedMarket;
+    /** The source market this was matched against. Present in browse mode (no marketId), absent in lookup mode. */
+    sourceMarket?: UnifiedMarket;
     relation: MatchRelation;
     confidence: number;
     reasoning: string | null;
@@ -39,8 +41,13 @@ export interface ArbitrageOpportunity {
     confidence?: number;
 }
 export interface FetchMarketMatchesParams {
+    /** Keyword search across matched market titles. */
+    query?: string;
+    /** Filter matches by category. */
+    category?: string;
     /** Pass a UnifiedMarket directly instead of marketId/slug/url. */
     market?: UnifiedMarket;
+    /** Lookup a specific market by ID. Omit for browse mode. */
     marketId?: string;
     slug?: string;
     url?: string;
@@ -48,12 +55,21 @@ export interface FetchMarketMatchesParams {
     minConfidence?: number;
     limit?: number;
     includePrices?: boolean;
+    /** Minimum price difference between venues. Browse mode only. */
+    minDifference?: number;
+    /** Sort order. Browse mode only. */
+    sort?: 'confidence' | 'volume' | 'priceDifference';
 }
 /** @deprecated Use {@link FetchMarketMatchesParams} instead. */
 export type FetchMatchesParams = FetchMarketMatchesParams;
 export interface FetchEventMatchesParams {
+    /** Keyword search across matched event titles. */
+    query?: string;
+    /** Filter matches by category. */
+    category?: string;
     /** Pass a UnifiedEvent directly instead of eventId/slug. */
     event?: UnifiedEvent;
+    /** Lookup a specific event by ID. Omit for browse mode. */
     eventId?: string;
     slug?: string;
     relation?: MatchRelation;
@@ -68,6 +84,32 @@ export interface FetchArbitrageParams {
     /** Comma-separated relation types to include (default: 'identity'). */
     relations?: MatchRelation[];
 }
+export interface MatchedMarketPair {
+    marketA: UnifiedMarket;
+    marketB: UnifiedMarket;
+    priceDifference: number;
+    venueA: string;
+    venueB: string;
+    priceA: number;
+    priceB: number;
+    /** The set-theoretic relation between the two markets (e.g. identity, subset). */
+    relation?: MatchRelation;
+    /** Match confidence score (0.0 to 1.0). */
+    confidence?: number;
+    /** Why the two markets were matched. */
+    reasoning?: string | null;
+}
+/** @deprecated Use {@link MatchedMarketPair} instead. */
+export type MatchedPricePair = MatchedMarketPair;
+export interface FetchMatchedMarketsParams {
+    minDifference?: number;
+    category?: string;
+    limit?: number;
+    /** Comma-separated relation types to include (default: 'identity'). */
+    relations?: MatchRelation[];
+}
+/** @deprecated Use {@link FetchMatchedMarketsParams} instead. */
+export type FetchMatchedPricesParams = FetchMatchedMarketsParams;
 export interface RouterMarketSearchParams {
     query?: string;
     sourceExchange?: string;

package/dist/server/method-verbs.json

@@ -374,7 +374,7 @@
       {
         "name": "params",
         "kind": "object",
-        "optional": false
+        "optional": true
       }
     ]
   },
@@ -384,7 +384,7 @@
       {
         "name": "params",
         "kind": "object",
-        "optional": false
+        "optional": true
       }
     ]
   },
@@ -398,6 +398,36 @@
       }
     ]
   },
+  "fetchRelatedMarkets": {
+    "verb": "get",
+    "args": [
+      {
+        "name": "params",
+        "kind": "object",
+        "optional": false
+      }
+    ]
+  },
+  "fetchMatchedMarkets": {
+    "verb": "get",
+    "args": [
+      {
+        "name": "params",
+        "kind": "object",
+        "optional": true
+      }
+    ]
+  },
+  "fetchMatchedPrices": {
+    "verb": "get",
+    "args": [
+      {
+        "name": "params",
+        "kind": "object",
+        "optional": true
+      }
+    ]
+  },
   "fetchHedges": {
     "verb": "get",
     "args": [