pmxt-core 2.46.14 → 2.48.0

package/dist/exchanges/smarkets/index.js

@@ -16,6 +16,7 @@ const logger_1 = require("../../utils/logger");
 class SmarketsExchange extends BaseExchange_1.PredictionMarketExchange {
     capabilityOverrides = {
         fetchPositions: 'emulated',
+        fetchSeries: false,
     };
     auth;
     loginPromise = null;
@@ -149,6 +150,10 @@ class SmarketsExchange extends BaseExchange_1.PredictionMarketExchange {
         return allMarkets.slice(offset, offset + limit);
     }
     async fetchEventsImpl(params) {
+        // Venue does not expose a series concept; honoring `params.series` by
+        // returning [] rather than ignoring the filter.
+        if (params.series !== undefined)
+            return [];
         const rawEvents = await this.fetcher.fetchRawEvents(params);
         const limit = params?.limit || 250000;
         const query = (params?.query || '').toLowerCase();

package/dist/exchanges/smarkets/normalizer.js

@@ -2,7 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SmarketsNormalizer = void 0;
 const market_utils_1 = require("../../utils/market-utils");
+const metadata_1 = require("../../utils/metadata");
 const price_1 = require("./price");
+// Raw Smarkets event fields already promoted to first-class Unified columns —
+// excluded from sourceMetadata so we capture only vendor data not in the
+// unified shape.
+const SMARKETS_PROMOTED_EVENT_KEYS = [
+    'id', 'name', 'description', 'slug', 'full_slug',
+    'start_datetime', 'end_date',
+];
+// Raw Smarkets market fields already promoted to first-class Unified columns.
+const SMARKETS_PROMOTED_MARKET_KEYS = [
+    'id', 'event_id', 'name', 'slug', 'description',
+    'category', 'categories',
+];
 // ----------------------------------------------------------------------------
 // Helpers
 // ----------------------------------------------------------------------------
@@ -94,6 +107,9 @@ class SmarketsNormalizer {
             url: buildEventUrl(event),
             category,
             tags,
+            // event_id is promoted to eventId; parent_id lives on the raw event
+            // (not a recurring/series market field), so no extra is needed.
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(market, SMARKETS_PROMOTED_MARKET_KEYS),
         };
         (0, market_utils_1.addBinaryOutcomes)(um);
         return um;
@@ -116,6 +132,10 @@ class SmarketsNormalizer {
             url: buildEventUrl(raw.event),
             category,
             tags: category ? [category] : [],
+            // Captures non-promoted event fields: state, type, parent_id,
+            // start_date, created, modified, bettable, hidden, inplay_enabled,
+            // short_name, seo_description, special_rules, chart_time_period, etc.
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw.event, SMARKETS_PROMOTED_EVENT_KEYS),
         };
     }
     normalizeOrderBook(raw, _id) {

package/dist/exchanges/suibets/index.d.ts

@@ -33,6 +33,7 @@ export declare class SuiBetsExchange extends PredictionMarketExchange {
         fetchPositions: true;
         watchOrderBook: false;
         watchTrades: false;
+        fetchSeries: false;
     };
     private readonly config;
     private readonly fetcher;

package/dist/exchanges/suibets/index.js

@@ -34,6 +34,7 @@ class SuiBetsExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchPositions: true,
         watchOrderBook: false,
         watchTrades: false,
+        fetchSeries: false,
     };
     config;
     fetcher;
@@ -72,6 +73,10 @@ class SuiBetsExchange extends BaseExchange_1.PredictionMarketExchange {
             .filter((m) => m !== null);
     }
     async fetchEventsImpl(params) {
+        // Venue does not expose a series concept; honoring `params.series` by returning [] rather than ignoring the filter.
+        if (params.series !== undefined) {
+            return [];
+        }
         const raw = await this.fetcher.fetchRawEvents(params);
         return raw
             .map(r => this.normalizer.normalizeEvent(r))

package/dist/exchanges/suibets/normalizer.js

@@ -1,7 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SuibetsNormalizer = void 0;
+const metadata_1 = require("../../utils/metadata");
 const utils_1 = require("./utils");
+// Raw SuiBets offer fields already promoted to first-class UnifiedMarket columns.
+// Omit these from sourceMetadata to capture only vendor-specific data not
+// represented by the unified shape.
+const SUIBETS_PROMOTED_OFFER_KEYS = [
+    'id', 'matchId', 'matchName', 'homeTeam', 'awayTeam',
+    'creatorOdds', 'creatorStake', 'remainingStake', 'totalMatched',
+    'matchDate', 'expiresAt', 'status', 'onchainOfferId',
+    'leagueName', 'sport', 'isOnchain',
+];
+// Raw SuiBets event fields already promoted to first-class UnifiedEvent columns.
+const SUIBETS_PROMOTED_EVENT_KEYS = [
+    'id', 'name', 'homeTeam', 'awayTeam', 'sport', 'leagueName', 'offers',
+];
 function liquidity(offer) {
     const remaining = offer.remainingStake ?? offer.creatorStake;
     return (0, utils_1.mistToSui)(remaining);
@@ -57,6 +71,9 @@ class SuibetsNormalizer {
             contractAddress: raw.onchainOfferId,
             yes: creatorOutcome,
             no: takerOutcome,
+            // Retains creatorWallet, creatorTeam, takerStake, currency \u2014 fields
+            // that are vendor-specific and not promoted to any unified column.
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw, SUIBETS_PROMOTED_OFFER_KEYS),
         };
         return market;
     }
@@ -84,6 +101,9 @@ class SuibetsNormalizer {
             url: 'https://suibets.replit.app/p2p',
             category: 'Sports',
             tags: ['Sports', 'P2P', 'Sui', raw.sport, raw.leagueName].filter((t) => Boolean(t)),
+            // Retains matchDate and status \u2014 event-level fields not promoted to
+            // any first-class UnifiedEvent column.
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw, SUIBETS_PROMOTED_EVENT_KEYS),
         };
     }
     normalizePosition(raw) {

package/dist/router/Router.d.ts

@@ -1,5 +1,5 @@
-import { PredictionMarketExchange, type MarketFetchParams, type EventFetchParams } from '../BaseExchange';
-import type { UnifiedMarket, UnifiedEvent, OrderBook } from '../types';
+import { PredictionMarketExchange, type MarketFetchParams, type EventFetchParams, type SeriesFetchParams } from '../BaseExchange';
+import type { UnifiedMarket, UnifiedEvent, UnifiedSeries, OrderBook } 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;
@@ -9,6 +9,33 @@ export declare class Router extends PredictionMarketExchange {
     get name(): string;
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params?: EventFetchParams): Promise<UnifiedEvent[]>;
+    /**
+     * Fan out fetchEvents({series: venueSeriesId}) to each venue in the
+     * mapping, collect all results, and tag each event with its sourceExchange.
+     */
+    private fetchEventsForMappedSeries;
+    /**
+     * Cross-venue series fetch.
+     *
+     * - If `params.id` matches a normalized id in SERIES_MAP, returns a single
+     *   synthesized `UnifiedSeries` whose `events` is the concatenation of
+     *   `fetchEvents({series: venueSeriesId})` results from each mapped venue.
+     * - Otherwise fans out `fetchSeries(params)` to all venue instances with
+     *   `has.fetchSeries !== false`, collects, and returns deduplicated results
+     *   tagged with their `sourceExchange`.
+     */
+    protected fetchSeriesImpl(params: SeriesFetchParams): Promise<UnifiedSeries[]>;
+    /**
+     * Build a single synthesized `UnifiedSeries` from the SERIES_MAP entry by
+     * fetching events from all mapped venues and concatenating them.
+     */
+    private fetchSynthesizedSeries;
+    /**
+     * Fan out `fetchSeries(params)` to all venue instances whose
+     * `has.fetchSeries` is not `false`. Tag each result with its originating
+     * venue name.
+     */
+    private fanOutFetchSeries;
     fetchOrderBook(outcomeId: string, limit?: number, params?: Record<string, any>): Promise<OrderBook>;
     fetchMarketMatches(params?: FetchMarketMatchesParams): Promise<MatchResult[]>;
     /**

package/dist/router/Router.js

@@ -5,6 +5,7 @@ const BaseExchange_1 = require("../BaseExchange");
 const errors_1 = require("../errors");
 const logger_1 = require("../utils/logger");
 const client_1 = require("./client");
+const series_map_1 = require("./series-map");
 // ---------------------------------------------------------------------------
 // Orderbook merge utilities
 // ---------------------------------------------------------------------------
@@ -127,6 +128,18 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
         return response;
     }
     async fetchEventsImpl(params) {
+        // When a normalized series id is requested, fan out to each mapped venue
+        // using the venue-native series id and aggregate the results.
+        if (params?.series !== undefined) {
+            const normalized = params.series;
+            const entry = series_map_1.SERIES_MAP.find((e) => e.id === normalized);
+            if (entry !== undefined) {
+                return this.fetchEventsForMappedSeries(entry.venues, params);
+            }
+            // Not a known normalized id — fall through and pass the raw value to
+            // the hosted search endpoint (single-venue callers using vendor-native
+            // ids still work).
+        }
         const response = await this.client.searchEvents({
             query: params?.query,
             category: params?.category,
@@ -138,6 +151,138 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
         }
         return response;
     }
+    /**
+     * Fan out fetchEvents({series: venueSeriesId}) to each venue in the
+     * mapping, collect all results, and tag each event with its sourceExchange.
+     */
+    async fetchEventsForMappedSeries(venueMap, baseParams) {
+        const venueEntries = Object.entries(venueMap);
+        if (venueEntries.length === 0)
+            return [];
+        const fetchResults = await Promise.all(venueEntries.map(async ([venueName, venueSeriesId]) => {
+            const exchange = this.localExchanges[venueName];
+            if (!exchange) {
+                logger_1.logger.debug(`Router.fetchEventsForMappedSeries: no exchange instance for venue "${venueName}", skipping`);
+                return [];
+            }
+            try {
+                const events = await exchange.fetchEvents({
+                    ...baseParams,
+                    series: venueSeriesId,
+                });
+                return events.map((ev) => ({
+                    ...ev,
+                    sourceExchange: ev.sourceExchange ?? venueName,
+                }));
+            }
+            catch (error) {
+                logger_1.logger.warn(`Router.fetchEventsForMappedSeries: fetchEvents failed for venue "${venueName}" ` +
+                    `series "${venueSeriesId}": ${error instanceof Error ? error.message : String(error)}`);
+                return [];
+            }
+        }));
+        return fetchResults.flat();
+    }
+    // -----------------------------------------------------------------------
+    // Cross-venue series (series-map + fan-out)
+    // -----------------------------------------------------------------------
+    /**
+     * Cross-venue series fetch.
+     *
+     * - If `params.id` matches a normalized id in SERIES_MAP, returns a single
+     *   synthesized `UnifiedSeries` whose `events` is the concatenation of
+     *   `fetchEvents({series: venueSeriesId})` results from each mapped venue.
+     * - Otherwise fans out `fetchSeries(params)` to all venue instances with
+     *   `has.fetchSeries !== false`, collects, and returns deduplicated results
+     *   tagged with their `sourceExchange`.
+     */
+    async fetchSeriesImpl(params) {
+        const requestedId = params.id;
+        if (requestedId !== undefined) {
+            const entry = series_map_1.SERIES_MAP.find((e) => e.id === requestedId);
+            if (entry !== undefined) {
+                return this.fetchSynthesizedSeries(entry, params);
+            }
+        }
+        return this.fanOutFetchSeries(params);
+    }
+    /**
+     * Build a single synthesized `UnifiedSeries` from the SERIES_MAP entry by
+     * fetching events from all mapped venues and concatenating them.
+     */
+    async fetchSynthesizedSeries(entry, params) {
+        const venueEntries = Object.entries(entry.venues);
+        const eventsPerVenue = await Promise.all(venueEntries.map(async ([venueName, venueSeriesId]) => {
+            const exchange = this.localExchanges[venueName];
+            if (!exchange) {
+                logger_1.logger.debug(`Router.fetchSynthesizedSeries: no exchange instance for venue "${venueName}", skipping`);
+                return [];
+            }
+            try {
+                const events = await exchange.fetchEvents({ series: venueSeriesId });
+                return events.map((ev) => ({
+                    ...ev,
+                    sourceExchange: ev.sourceExchange ?? venueName,
+                }));
+            }
+            catch (error) {
+                logger_1.logger.warn(`Router.fetchSynthesizedSeries: fetchEvents failed for venue "${venueName}" ` +
+                    `series "${venueSeriesId}": ${error instanceof Error ? error.message : String(error)}`);
+                return [];
+            }
+        }));
+        const allEvents = eventsPerVenue.flat();
+        const synthesized = {
+            id: entry.id,
+            title: entry.title,
+            events: allEvents,
+            sourceExchange: 'Router',
+        };
+        // Apply limit/offset if the caller passed them (BaseExchange.fetchSeries strips
+        // them before calling fetchSeriesImpl, but guard defensively).
+        const limit = params.limit;
+        const offset = params.offset ?? 0;
+        if (limit !== undefined) {
+            return [{ ...synthesized, events: allEvents.slice(offset, offset + limit) }];
+        }
+        return [synthesized];
+    }
+    /**
+     * Fan out `fetchSeries(params)` to all venue instances whose
+     * `has.fetchSeries` is not `false`. Tag each result with its originating
+     * venue name.
+     */
+    async fanOutFetchSeries(params) {
+        const venueEntries = Object.entries(this.localExchanges);
+        if (venueEntries.length === 0)
+            return [];
+        const fetchResults = await Promise.all(venueEntries.map(async ([venueName, exchange]) => {
+            if (exchange.has.fetchSeries === false)
+                return [];
+            // When params.id is a venue-native id on this specific venue,
+            // pass it through directly so single-venue lookups still work.
+            let venueParams = params;
+            if (params.id !== undefined) {
+                const nativeId = (0, series_map_1.getVenueSeriesId)(params.id, venueName);
+                if (nativeId !== undefined) {
+                    venueParams = { ...params, id: nativeId };
+                }
+            }
+            try {
+                const series = await exchange.fetchSeries(venueParams);
+                return series.map((s) => ({
+                    ...s,
+                    sourceExchange: s.sourceExchange ?? venueName,
+                }));
+            }
+            catch (error) {
+                logger_1.logger.warn(`Router.fanOutFetchSeries: fetchSeries failed for venue "${venueName}": ` +
+                    `${error instanceof Error ? error.message : String(error)}`);
+                return [];
+            }
+        }));
+        return fetchResults.flat();
+    }
     // -----------------------------------------------------------------------
     // Unified orderbook (cross-exchange merge)
     // -----------------------------------------------------------------------

package/dist/router/index.d.ts

@@ -1,3 +1,4 @@
 export { Router } from './Router';
 export { PmxtApiClient } from './client';
 export * from './types';
+export * from './series-map';

package/dist/router/index.js

@@ -20,3 +20,4 @@ Object.defineProperty(exports, "Router", { enumerable: true, get: function () {
 var client_1 = require("./client");
 Object.defineProperty(exports, "PmxtApiClient", { enumerable: true, get: function () { return client_1.PmxtApiClient; } });
 __exportStar(require("./types"), exports);
+__exportStar(require("./series-map"), exports);

package/dist/router/series-map.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Curated mapping from normalized PMXT series ids to per-venue native series ids.
+ *
+ * The normalized ids use kebab-case following the pattern:
+ *   <sport-or-domain>-<category-or-format>
+ *
+ * Venue-native ids are the raw tickers/slugs each platform uses.
+ * It is intentional for some entries to have only partial venue coverage --
+ * the Router handles missing venue mappings gracefully by skipping that venue.
+ */
+export interface RouterSeriesEntry {
+    /** Normalized PMXT series id (kebab-case). */
+    id: string;
+    /** Human-readable title. */
+    title: string;
+    /** Map of venueName -> venue-native series id. */
+    venues: {
+        readonly [venueName: string]: string;
+    };
+}
+export declare const SERIES_MAP: readonly RouterSeriesEntry[];
+/**
+ * Resolve a normalized PMXT series id to the venue-native series id for a
+ * given venue. Returns `undefined` when either the normalized id is not in the
+ * map or that venue has no mapping for it.
+ */
+export declare function getVenueSeriesId(normalizedId: string, venue: string): string | undefined;
+/**
+ * Reverse-lookup: given a venue name and a venue-native series id, return the
+ * normalized PMXT series id. Returns `undefined` when not found.
+ */
+export declare function getNormalizedSeriesId(venue: string, venueSeriesId: string): string | undefined;

package/dist/router/series-map.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Curated mapping from normalized PMXT series ids to per-venue native series ids.
+ *
+ * The normalized ids use kebab-case following the pattern:
+ *   <sport-or-domain>-<category-or-format>
+ *
+ * Venue-native ids are the raw tickers/slugs each platform uses.
+ * It is intentional for some entries to have only partial venue coverage --
+ * the Router handles missing venue mappings gracefully by skipping that venue.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERIES_MAP = void 0;
+exports.getVenueSeriesId = getVenueSeriesId;
+exports.getNormalizedSeriesId = getNormalizedSeriesId;
+exports.SERIES_MAP = [
+    {
+        id: 'tennis-atp-match',
+        title: 'ATP Match Winner',
+        venues: {
+            kalshi: 'KXATPSETWINNER',
+            polymarket: 'atp',
+        },
+    },
+    {
+        id: 'tennis-atp-challenger',
+        title: 'ATP Challenger Match Winner',
+        venues: {
+            kalshi: 'KXATPCHALLENGERMATCH',
+        },
+    },
+    {
+        id: 'tennis-wta-match',
+        title: 'WTA Match Winner',
+        venues: {
+            kalshi: 'KXWTASETWINNER',
+            polymarket: 'wta',
+        },
+    },
+    {
+        id: 'tennis-itf-match',
+        title: 'ITF Match Winner',
+        venues: {
+            kalshi: 'KXITFMATCH',
+        },
+    },
+    {
+        id: 'tennis-itf-women-match',
+        title: "ITF Women's Match Winner",
+        venues: {
+            kalshi: 'KXITFWMATCH',
+        },
+    },
+    {
+        id: 'nfl',
+        title: 'NFL Game Winner',
+        venues: {
+            kalshi: 'KXNFLGAME',
+            polymarket: 'nfl-game',
+        },
+    },
+    {
+        id: 'nba',
+        title: 'NBA Game Winner',
+        venues: {
+            kalshi: 'KXNBAGAME',
+            polymarket: 'nba',
+        },
+    },
+    {
+        id: 'ncaa-basketball',
+        title: 'NCAA Basketball Game Winner',
+        venues: {
+            kalshi: 'KXNCAABBGAME',
+        },
+    },
+    {
+        id: 'ufc',
+        title: 'UFC Fight Winner',
+        venues: {
+            polymarket: 'ufc',
+        },
+    },
+    {
+        id: 'soccer-fifa-world-cup',
+        title: 'FIFA World Cup Match Winner',
+        venues: {
+            polymarket: 'soccer-fifwc',
+        },
+    },
+    {
+        id: 'esports-cs2-map',
+        title: 'CS2 Map Winner',
+        venues: {
+            kalshi: 'KXCS2MAP',
+        },
+    },
+    {
+        id: 'esports-lol-map',
+        title: 'League of Legends Map Winner',
+        venues: {
+            kalshi: 'KXLOLMAP',
+        },
+    },
+    {
+        id: 'crypto-btc-15m',
+        title: 'Bitcoin Price (15-minute)',
+        venues: {
+            kalshi: 'KXBTC15M',
+        },
+    },
+    {
+        id: 'crypto-eth-15m',
+        title: 'Ethereum Price (15-minute)',
+        venues: {
+            kalshi: 'KXETH15M',
+        },
+    },
+    {
+        id: 'crypto-sol-15m',
+        title: 'Solana Price (15-minute)',
+        venues: {
+            kalshi: 'KXSOL15M',
+        },
+    },
+];
+// ---------------------------------------------------------------------------
+// Lookup helpers (O(n) over small constant array; acceptable for this table)
+// ---------------------------------------------------------------------------
+/**
+ * Resolve a normalized PMXT series id to the venue-native series id for a
+ * given venue. Returns `undefined` when either the normalized id is not in the
+ * map or that venue has no mapping for it.
+ */
+function getVenueSeriesId(normalizedId, venue) {
+    const entry = exports.SERIES_MAP.find((e) => e.id === normalizedId);
+    return entry?.venues[venue];
+}
+/**
+ * Reverse-lookup: given a venue name and a venue-native series id, return the
+ * normalized PMXT series id. Returns `undefined` when not found.
+ */
+function getNormalizedSeriesId(venue, venueSeriesId) {
+    const entry = exports.SERIES_MAP.find((e) => e.venues[venue] === venueSeriesId);
+    return entry?.id;
+}

package/dist/server/method-verbs.json

@@ -49,6 +49,16 @@
       }
     ]
   },
+  "fetchSeries": {
+    "verb": "get",
+    "args": [
+      {
+        "name": "params",
+        "kind": "object",
+        "optional": true
+      }
+    ]
+  },
   "fetchMarket": {
     "verb": "get",
     "args": [