pmxt-core 2.46.14 → 2.48.0

package/dist/BaseExchange.d.ts

@@ -1,6 +1,6 @@
 import { AxiosInstance } from 'axios';
 import { SubscribedAddressSnapshot, SubscriptionOption } from './subscriber/base';
-import { Balance, BuiltOrder, CandleInterval, CreateOrderParams, Order, OrderBook, Position, PriceCandle, Trade, UnifiedEvent, UnifiedMarket, UserTrade } from './types';
+import { Balance, BuiltOrder, CandleInterval, CreateOrderParams, Order, OrderBook, Position, PriceCandle, Trade, UnifiedEvent, UnifiedMarket, UnifiedSeries, UserTrade } from './types';
 import { ExecutionPriceResult } from './utils/math';
 import type { FetchMarketMatchesParams, FetchMatchesParams, FetchEventMatchesParams, FetchArbitrageParams, FetchMatchedMarketsParams, FetchMatchedPricesParams, MatchResult, EventMatchResult, PriceComparison, ArbitrageOpportunity, MatchedMarketPair, MatchedPricePair } from './router/types';
 export interface ApiEndpoint {
@@ -74,6 +74,8 @@ export interface EventFetchParams {
     searchIn?: 'title' | 'description' | 'both';
     eventId?: string;
     slug?: string;
+    /** Filter events by their parent series. Accepts the venue-native series id / ticker / slug (e.g. Kalshi `"KXATPMATCH"`, Polymarket `"wta"`). Passed through to the vendor where supported, otherwise applied to `sourceMetadata` after fetch. */
+    series?: string;
     /** Optional client-side filter applied after fetching */
     filter?: EventFilterCriteria;
     /** Filter by category. Each event belongs to a venue-assigned category such as "Sports", "Politics", "Crypto", "Bitcoin", "Soccer", "Economic Policy" (Polymarket) or "Sports", "Mentions" (Kalshi). */
@@ -81,6 +83,24 @@ export interface EventFetchParams {
     /** Filter by tags. Returns events matching ANY of the provided tags. Tags are more specific than categories -- for example a "Politics" event might carry tags ["Politics", "Geopolitics", "Middle East", "Iran"]. Common tags include "Crypto", "Elections", "Fed Rates", "FIFA World Cup", "Trump". */
     tags?: string[];
 }
+/**
+ * Parameters for `fetchSeries`. Venues that don't expose a series concept
+ * return an empty array regardless of the filters.
+ */
+export interface SeriesFetchParams {
+    /** Direct lookup by venue-native series id (e.g. "KXATPMATCH" on Kalshi, "atp" or "1" on Polymarket Gamma). When set, the result is the matching series with its events populated where the venue supports it. */
+    id?: string;
+    /** Lookup by series slug (e.g. "wta", "nfl"). */
+    slug?: string;
+    /** Keyword search across series title / description. */
+    query?: string;
+    /** Filter by recurrence cadence ('daily', 'weekly', 'annual', ...). */
+    recurrence?: string;
+    /** Maximum number of results to return. */
+    limit?: number;
+    /** Pagination offset. */
+    offset?: number;
+}
 /**
  * Deprecated - use OHLCVParams or TradesParams instead. Resolution is optional for backward compatibility.
  */
@@ -219,6 +239,8 @@ export interface ExchangeHas {
     fetchMarkets: ExchangeCapability;
     /** Whether this exchange supports fetching events. */
     fetchEvents: ExchangeCapability;
+    /** Whether this exchange exposes a recurring-series concept (Series -> Event -> Market -> Outcome). Venues without one return `false` and an empty array from `fetchSeries`. */
+    fetchSeries: ExchangeCapability;
     /** Whether this exchange supports fetching OHLCV candles. */
     fetchOHLCV: ExchangeCapability;
     /** Whether this exchange supports fetching the order book. */
@@ -451,6 +473,18 @@ export declare abstract class PredictionMarketExchange {
      * @note Some exchanges (like Limitless) may only support status 'active' for search results.
      */
     fetchEvents(params?: EventFetchParams): Promise<UnifiedEvent[]>;
+    /**
+     * Fetch the recurring series (fourth tier above Event -> Market -> Outcome)
+     * that this venue exposes. Returns an empty array on venues without a
+     * series concept (Limitless, Smarkets, Probable, Metaculus, Baozi,
+     * Hyperliquid, SuiBets, Polymarket US).
+     *
+     * - `params.id` -> a single matching series with its events populated where supported.
+     * - no params -> the full list, typically without nested events for payload size.
+     *
+     * @returns Array of unified series. Always an array, including the singular-lookup case.
+     */
+    fetchSeries(params?: SeriesFetchParams): Promise<UnifiedSeries[]>;
     /**
      * Fetch a single market by lookup parameters.
      * Convenience wrapper around fetchMarkets() that returns a single result or throws MarketNotFound.
@@ -782,6 +816,13 @@ export declare abstract class PredictionMarketExchange {
      * Implementation for searching events by keyword.
      */
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    /**
+     * @internal
+     * Implementation for fetching recurring series. Override in venue adapters
+     * that expose a series concept; the default returns an empty array so
+     * venues without one are silently a no-op.
+     */
+    protected fetchSeriesImpl(_params: SeriesFetchParams): Promise<UnifiedSeries[]>;
     /**
      * Call an implicit API method by its operationId (or auto-generated name).
      * Provides a typed entry point so unified methods can delegate to the implicit API

package/dist/BaseExchange.js

@@ -361,6 +361,23 @@ class PredictionMarketExchange {
         const start = offset ?? 0;
         return limit !== undefined ? events.slice(start, start + limit) : events.slice(start);
     }
+    /**
+     * Fetch the recurring series (fourth tier above Event -> Market -> Outcome)
+     * that this venue exposes. Returns an empty array on venues without a
+     * series concept (Limitless, Smarkets, Probable, Metaculus, Baozi,
+     * Hyperliquid, SuiBets, Polymarket US).
+     *
+     * - `params.id` -> a single matching series with its events populated where supported.
+     * - no params -> the full list, typically without nested events for payload size.
+     *
+     * @returns Array of unified series. Always an array, including the singular-lookup case.
+     */
+    async fetchSeries(params) {
+        const { limit, offset, ...venueParams } = params ?? {};
+        const series = await this.fetchSeriesImpl(venueParams);
+        const start = offset ?? 0;
+        return limit !== undefined ? series.slice(start, start + limit) : series.slice(start);
+    }
     /**
      * Fetch a single market by lookup parameters.
      * Convenience wrapper around fetchMarkets() that returns a single result or throws MarketNotFound.
@@ -1056,6 +1073,15 @@ class PredictionMarketExchange {
     async fetchEventsImpl(params) {
         throw new Error("Method fetchEventsImpl not implemented.");
     }
+    /**
+     * @internal
+     * Implementation for fetching recurring series. Override in venue adapters
+     * that expose a series concept; the default returns an empty array so
+     * venues without one are silently a no-op.
+     */
+    async fetchSeriesImpl(_params) {
+        return [];
+    }
     /**
      * Call an implicit API method by its operationId (or auto-generated name).
      * Provides a typed entry point so unified methods can delegate to the implicit API
@@ -1163,7 +1189,7 @@ class PredictionMarketExchange {
     // ----------------------------------------------------------------------------
     /** All keys that appear in ExchangeHas -- kept in sync via the exhaustive check below. */
     static _capabilityKeys = [
-        'fetchMarkets', 'fetchEvents', 'fetchOHLCV', 'fetchOrderBook', 'fetchOrderBooks',
+        'fetchMarkets', 'fetchEvents', 'fetchSeries', 'fetchOHLCV', 'fetchOrderBook', 'fetchOrderBooks',
         'fetchTrades', 'createOrder', 'cancelOrder', 'fetchOrder',
         'fetchOpenOrders', 'fetchPositions', 'fetchBalance',
         'watchAddress', 'unwatchAddress', 'watchOrderBook', 'watchOrderBooks',
@@ -1175,7 +1201,7 @@ class PredictionMarketExchange {
     // Compile-time exhaustiveness check: fails tsc if a key exists in
     // ExchangeHas but is missing from _capabilityKeys above.
     static _exhaustiveCheck = {
-        fetchMarkets: true, fetchEvents: true, fetchOHLCV: true,
+        fetchMarkets: true, fetchEvents: true, fetchSeries: true, fetchOHLCV: true,
         fetchOrderBook: true, fetchOrderBooks: true, fetchTrades: true, createOrder: true,
         cancelOrder: true, fetchOrder: true, fetchOpenOrders: true,
         fetchPositions: true, fetchBalance: true, watchAddress: true,
@@ -1194,6 +1220,7 @@ class PredictionMarketExchange {
     static _capabilityDelegates = {
         fetchMarkets: 'fetchMarketsImpl',
         fetchEvents: 'fetchEventsImpl',
+        fetchSeries: 'fetchSeriesImpl',
         watchOrderBooks: 'watchOrderBook',
         fetchMatches: 'fetchMarketMatches',
         fetchHedges: 'fetchRelatedMarkets',

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

@@ -12,6 +12,7 @@ export declare class BaoziExchange extends PredictionMarketExchange {
         fetchOpenOrders: "emulated";
         cancelOrder: false;
         watchTrades: false;
+        fetchSeries: false;
     };
     private auth?;
     private connection;

package/dist/exchanges/baozi/index.js

@@ -19,6 +19,7 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchOpenOrders: 'emulated',
         cancelOrder: false,
         watchTrades: false,
+        fetchSeries: false,
     };
     auth;
     connection;
@@ -59,6 +60,10 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         return this.normalizer.normalizeMarkets(rawMarkets, params);
     }
     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 rawMarkets = await this.fetcher.fetchRawEvents(params);
         return this.normalizer.normalizeEvents(rawMarkets, {
             query: params.query,

package/dist/exchanges/baozi/normalizer.js

@@ -35,6 +35,7 @@ class BaoziNormalizer {
             image: market.image,
             category: market.category,
             tags: market.tags,
+            sourceMetadata: market.sourceMetadata,
         };
     }
     normalizeMarkets(rawMarkets, params) {
@@ -60,6 +61,7 @@ class BaoziNormalizer {
             image: m.image,
             category: m.category,
             tags: m.tags,
+            sourceMetadata: m.sourceMetadata,
         }));
     }
     normalizeOrderBook(raw, outcomeId) {

package/dist/exchanges/baozi/utils.js

@@ -20,6 +20,7 @@ const web3_js_1 = require("@solana/web3.js");
 const bs58_1 = __importDefault(require("bs58"));
 const crypto_1 = require("crypto");
 const market_utils_1 = require("../../utils/market-utils");
+const metadata_1 = require("../../utils/metadata");
 const price_1 = require("./price");
 // ---------------------------------------------------------------------------
 // Constants
@@ -285,6 +286,31 @@ function parseRacePosition(data) {
     return { user, marketId, bets, totalBet, claimed };
 }
 // ---------------------------------------------------------------------------
+// Promoted key sets — fields already represented by first-class unified columns.
+// These are excluded from sourceMetadata to avoid duplication.
+// ---------------------------------------------------------------------------
+// BaoziMarket fields promoted to unified columns:
+//   question -> title
+//   resolutionTime -> resolutionDate
+//   yesPool / noPool -> volume + liquidity
+//   status -> status
+// pubkey is promoted to marketId; outcomeLabels / outcomePools -> outcomes
+const BAOZI_BOOLEAN_PROMOTED_KEYS = [
+    'question',
+    'resolutionTime',
+    'yesPool',
+    'noPool',
+    'status',
+];
+const BAOZI_RACE_PROMOTED_KEYS = [
+    'question',
+    'resolutionTime',
+    'totalPool',
+    'status',
+    'outcomeLabels',
+    'outcomePools',
+];
+// ---------------------------------------------------------------------------
 // Mapping to Unified Types
 // ---------------------------------------------------------------------------
 function mapBooleanToUnified(market, pubkey) {
@@ -326,6 +352,7 @@ function mapBooleanToUnified(market, pubkey) {
         url: `https://baozi.bet/market/${pubkey}`,
         category: undefined,
         tags: [`tier:${layerName(market.layer)}`, 'solana', 'pari-mutuel'],
+        sourceMetadata: (0, metadata_1.buildSourceMetadata)(market, BAOZI_BOOLEAN_PROMOTED_KEYS),
     };
     (0, market_utils_1.addBinaryOutcomes)(um);
     return um;
@@ -361,6 +388,7 @@ function mapRaceToUnified(market, pubkey) {
         url: `https://baozi.bet/market/${pubkey}`,
         category: undefined,
         tags: [`tier:${layerName(market.layer)}`, 'solana', 'pari-mutuel', 'race'],
+        sourceMetadata: (0, metadata_1.buildSourceMetadata)(market, BAOZI_RACE_PROMOTED_KEYS),
     };
     // For 2-outcome races, add binary convenience getters
     (0, market_utils_1.addBinaryOutcomes)(um);

package/dist/exchanges/gemini-titan/index.d.ts

@@ -1,5 +1,5 @@
-import { PredictionMarketExchange, MarketFilterParams, EventFetchParams, ExchangeCredentials } from '../../BaseExchange';
-import { UnifiedMarket, UnifiedEvent, OrderBook, Trade, Order, Position, CreateOrderParams, BuiltOrder } from '../../types';
+import { PredictionMarketExchange, MarketFilterParams, EventFetchParams, SeriesFetchParams, ExchangeCredentials } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, UnifiedSeries, OrderBook, Trade, Order, Position, CreateOrderParams, BuiltOrder } from '../../types';
 export interface GeminiTitanExchangeOptions {
     credentials?: ExchangeCredentials;
     sandbox?: boolean;
@@ -10,11 +10,15 @@ export declare class GeminiTitanExchange extends PredictionMarketExchange {
     private readonly normalizer;
     private readonly geminiAuth?;
     private geminiWs?;
+    protected readonly capabilityOverrides: {
+        fetchSeries: "emulated";
+    };
     constructor(credentials?: ExchangeCredentials | GeminiTitanExchangeOptions);
     get name(): string;
     private requireAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    protected fetchSeriesImpl(params: SeriesFetchParams): Promise<UnifiedSeries[]>;
     fetchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
     buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
     submitOrder(built: BuiltOrder): Promise<Order>;

package/dist/exchanges/gemini-titan/index.js

@@ -16,6 +16,9 @@ class GeminiTitanExchange extends BaseExchange_1.PredictionMarketExchange {
     normalizer;
     geminiAuth;
     geminiWs;
+    capabilityOverrides = {
+        fetchSeries: 'emulated',
+    };
     constructor(credentials) {
         const opts = credentials && 'credentials' in credentials
             ? credentials
@@ -63,10 +66,87 @@ class GeminiTitanExchange extends BaseExchange_1.PredictionMarketExchange {
     }
     async fetchEventsImpl(params) {
         const rawEvents = await this.fetcher.fetchRawEvents(params);
-        return rawEvents
+        let filtered = rawEvents;
+        // Client-side series filter: keep only events whose series id matches.
+        if (params.series) {
+            const seriesId = params.series;
+            filtered = rawEvents.filter((e) => {
+                if (e.series == null)
+                    return false;
+                const s = e.series;
+                const id = String(s['id'] ?? s['ticker'] ?? s['symbol'] ?? '');
+                return id === seriesId;
+            });
+        }
+        return filtered
             .map(e => this.normalizer.normalizeEventWithMarkets(e))
             .filter((e) => e !== null);
     }
+    async fetchSeriesImpl(params) {
+        // Gemini-Titan has no dedicated /series endpoint. Derive the catalog by
+        // fetching all events and grouping by the series id in event.series.
+        const rawEvents = await this.fetcher.fetchRawEvents({});
+        // Build a map from series id -> { rawSeries, rawEvents[] }
+        const seriesMap = new Map();
+        for (const event of rawEvents) {
+            if (event.series == null)
+                continue;
+            const s = event.series;
+            const id = String(s['id'] ?? s['ticker'] ?? s['symbol'] ?? '');
+            if (!id)
+                continue;
+            const existing = seriesMap.get(id);
+            if (existing) {
+                existing.raws.push(event);
+            }
+            else {
+                seriesMap.set(id, { raw: s, raws: [event] });
+            }
+        }
+        let entries = Array.from(seriesMap.entries()).map(([id, v]) => ({
+            id,
+            raw: v.raw,
+            raws: v.raws,
+        }));
+        // Apply params.id filter
+        if (params.id) {
+            entries = entries.filter((e) => e.id === params.id);
+        }
+        // Apply params.slug filter (treat slug same as id for Gemini series)
+        if (params.slug) {
+            const slug = params.slug;
+            entries = entries.filter((e) => {
+                const rawSlug = e.raw['slug'] != null ? String(e.raw['slug']) : e.id;
+                return rawSlug === slug;
+            });
+        }
+        // Apply params.query filter (title match)
+        if (params.query) {
+            const lowerQuery = params.query.toLowerCase();
+            entries = entries.filter((e) => {
+                const title = String(e.raw['title'] ?? e.raw['name'] ?? '');
+                return title.toLowerCase().includes(lowerQuery);
+            });
+        }
+        // Apply params.recurrence filter
+        if (params.recurrence) {
+            const recurrence = params.recurrence;
+            entries = entries.filter((e) => {
+                const freq = e.raw['frequency'] ?? e.raw['recurrence'];
+                return freq != null && String(freq) === recurrence;
+            });
+        }
+        return entries.map((e) => {
+            let events;
+            // When fetching by id, populate the events field.
+            if (params.id) {
+                events = e.raws
+                    .map((raw) => this.normalizer.normalizeEventWithMarkets(raw))
+                    .filter((ev) => ev !== null);
+            }
+            return this.normalizer.normalizeSeries(e.raw, events);
+        });
+    }
     async fetchOrderBook(outcomeId, _limit, _params) {
         const resolved = await this.resolveOutcomeAlias(outcomeId, _params);
         outcomeId = resolved.outcomeId;

package/dist/exchanges/gemini-titan/normalizer.d.ts

@@ -1,10 +1,16 @@
-import { UnifiedMarket, UnifiedEvent, OrderBook, Order, Position } from '../../types';
+import { UnifiedMarket, UnifiedEvent, UnifiedSeries, OrderBook, Order, Position } from '../../types';
 import { IExchangeNormalizer } from '../interfaces';
 import { GeminiRawEvent, GeminiRawContract, GeminiRawOrder, GeminiRawPosition, GeminiRawOrderBook } from './types';
 export declare class GeminiNormalizer implements IExchangeNormalizer<GeminiRawEvent, GeminiRawEvent> {
     normalizeMarket(raw: GeminiRawEvent): UnifiedMarket | null;
     normalizeEvent(raw: GeminiRawEvent): UnifiedEvent | null;
     normalizeEventWithMarkets(raw: GeminiRawEvent): UnifiedEvent | null;
+    /**
+     * Produce a UnifiedSeries from a Gemini `series` object (raw Record).
+     * The series id is taken from the first non-null of: id, ticker, symbol.
+     * `events` is optionally injected by the caller when doing a single-id lookup.
+     */
+    normalizeSeries(raw: Record<string, unknown>, events?: UnifiedEvent[]): UnifiedSeries;
     normalizeMarketsFromEvent(raw: GeminiRawEvent): UnifiedMarket[];
     normalizeContract(contract: GeminiRawContract, event: GeminiRawEvent): UnifiedMarket | null;
     normalizeOrderBook(raw: GeminiRawOrderBook, _outcomeId: string): OrderBook;

package/dist/exchanges/gemini-titan/normalizer.js

@@ -2,8 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeminiNormalizer = void 0;
 const market_utils_1 = require("../../utils/market-utils");
+const metadata_1 = require("../../utils/metadata");
 const utils_1 = require("./utils");
 const config_1 = require("./config");
+// Raw GeminiRawEvent fields already promoted to first-class unified columns.
+// Omitted from sourceMetadata so we capture only vendor data the unified shape
+// would otherwise drop.
+const GEMINI_PROMOTED_EVENT_KEYS = [
+    'ticker', // -> id
+    'title',
+    'description',
+    'slug',
+    'contracts', // -> markets (nested child array, always omitted)
+    'volume24h',
+    'imageUrl', // -> image
+    'category',
+    'tags',
+];
+// Raw GeminiRawContract fields already promoted to first-class unified columns.
+const GEMINI_PROMOTED_CONTRACT_KEYS = [
+    'instrumentSymbol', // -> marketId, slug
+    'label', // -> title
+    'description',
+    'ticker', // parent event ticker feeds eventId
+    'status', // -> status
+    'prices', // -> outcomes prices
+    'expiryDate', // -> resolutionDate
+];
 // ----------------------------------------------------------------------------
 // Helpers
 // ----------------------------------------------------------------------------
@@ -95,6 +120,7 @@ class GeminiNormalizer {
             category: raw.category,
             tags: raw.tags ?? [],
             image: raw.imageUrl,
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw, GEMINI_PROMOTED_EVENT_KEYS),
         };
     }
     normalizeEventWithMarkets(raw) {
@@ -115,6 +141,29 @@ class GeminiNormalizer {
             volume24h: markets.reduce((sum, m) => sum + m.volume24h, 0),
         };
     }
+    /**
+     * Produce a UnifiedSeries from a Gemini `series` object (raw Record).
+     * The series id is taken from the first non-null of: id, ticker, symbol.
+     * `events` is optionally injected by the caller when doing a single-id lookup.
+     */
+    normalizeSeries(raw, events) {
+        const id = String(raw['id'] ?? raw['ticker'] ?? raw['symbol'] ?? '');
+        const ticker = raw['ticker'] != null ? String(raw['ticker']) : undefined;
+        const title = String(raw['title'] ?? raw['name'] ?? id);
+        const recurrence = raw['frequency'] != null
+            ? String(raw['frequency'])
+            : raw['recurrence'] != null
+                ? String(raw['recurrence'])
+                : null;
+        return {
+            id,
+            ticker,
+            title,
+            recurrence,
+            events,
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw, ['id', 'ticker', 'title', 'name', 'frequency', 'recurrence']),
+        };
+    }
     normalizeMarketsFromEvent(raw) {
         const markets = [];
         for (const contract of raw.contracts) {
@@ -158,6 +207,10 @@ class GeminiNormalizer {
         if (event.category && !tags.includes(event.category)) {
             tags.push(event.category);
         }
+        const seriesExtra = {};
+        if (event.series != null) {
+            seriesExtra['series'] = event.series;
+        }
         const um = {
             marketId,
             eventId: event.ticker,
@@ -173,6 +226,7 @@ class GeminiNormalizer {
             tags,
             tickSize: config_1.TICK_SIZE,
             status: mapEventStatus(contract.status),
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(contract, GEMINI_PROMOTED_CONTRACT_KEYS, Object.keys(seriesExtra).length > 0 ? seriesExtra : undefined),
         };
         (0, market_utils_1.addBinaryOutcomes)(um);
         return um;

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

@@ -5,6 +5,9 @@ export interface HyperliquidExchangeOptions {
     testnet?: boolean;
 }
 export declare class HyperliquidExchange extends PredictionMarketExchange {
+    protected readonly capabilityOverrides: {
+        fetchSeries: false;
+    };
     private readonly config;
     private readonly fetcher;
     private readonly normalizer;

package/dist/exchanges/hyperliquid/index.js

@@ -9,6 +9,9 @@ const normalizer_1 = require("./normalizer");
 const auth_1 = require("./auth");
 const errors_2 = require("./errors");
 class HyperliquidExchange extends BaseExchange_1.PredictionMarketExchange {
+    capabilityOverrides = {
+        fetchSeries: false,
+    };
     config;
     fetcher;
     normalizer;
@@ -69,6 +72,10 @@ class HyperliquidExchange 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 [rawQuestions, meta, mids] = await Promise.all([
             this.fetcher.fetchRawEvents(params),
             this.fetcher.fetchOutcomeMeta(),

package/dist/exchanges/hyperliquid/normalizer.js

@@ -2,8 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HyperliquidNormalizer = void 0;
 const market_utils_1 = require("../../utils/market-utils");
+const metadata_1 = require("../../utils/metadata");
 const utils_1 = require("./utils");
 const config_1 = require("./config");
+// Raw Hyperliquid outcome fields already promoted to first-class Unified columns —
+// excluded from sourceMetadata so we capture only what the unified shape would drop.
+const HL_PROMOTED_MARKET_KEYS = [
+    'outcome', // -> marketId
+    'name', // -> title
+    'description', // -> description
+    'sideSpecs', // -> outcomes (labels)
+];
+// Raw Hyperliquid question fields already promoted to first-class Unified columns.
+// namedOutcomes is omitted as well — it is the child-markets array and must not
+// be duplicated in metadata.
+const HL_PROMOTED_EVENT_KEYS = [
+    'question', // -> id / eventId
+    'name', // -> title
+    'description', // -> description
+    'namedOutcomes', // -> markets (child-markets array)
+];
 function parseDescription(description) {
     // Hyperliquid outcome descriptions use key:value pairs separated by |
     // e.g. "class:priceBinary|underlying:BTC|expiry:20260509-0600|targetPrice:79583|period:1d"
@@ -165,6 +183,7 @@ class HyperliquidNormalizer {
             tags,
             tickSize: 0.001,
             status: 'active',
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(outcome, HL_PROMOTED_MARKET_KEYS),
         };
         (0, market_utils_1.addBinaryOutcomes)(um);
         return um;
@@ -196,6 +215,7 @@ class HyperliquidNormalizer {
             url: buildEventUrl(raw.question),
             category: underlying ? 'Crypto' : undefined,
             tags,
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw, HL_PROMOTED_EVENT_KEYS),
         };
     }
     normalizeEventWithMarkets(raw, outcomeMeta, mids) {

package/dist/exchanges/kalshi/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-05-26T15:22:20.006Z
+ * Generated at: 2026-05-30T13:35:15.520Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const kalshiApiSpec: {

package/dist/exchanges/kalshi/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.kalshiApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-05-26T15:22:20.006Z
+ * Generated at: 2026-05-30T13:35:15.520Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {

package/dist/exchanges/kalshi/fetcher.d.ts

@@ -44,6 +44,14 @@ interface KalshiSeriesInfo {
     title?: string;
     tags?: string[];
 }
+export interface KalshiRawSeries {
+    ticker: string;
+    title?: string;
+    tags?: string[];
+    frequency?: string;
+    category?: string;
+    [key: string]: unknown;
+}
 export interface KalshiRawEventPage {
     events: KalshiRawEvent[];
     cursor?: string | null;
@@ -153,6 +161,7 @@ export declare class KalshiFetcher implements IExchangeFetcher<KalshiRawEvent, K
     }>;
     fetchRawOrders(queryParams: Record<string, any>): Promise<KalshiRawOrder[]>;
     fetchRawHistoricalOrders(queryParams: Record<string, any>): Promise<KalshiRawOrder[]>;
+    fetchRawSeriesList(): Promise<KalshiRawSeries[]>;
     fetchRawSeriesMap(): Promise<Map<string, KalshiSeriesInfo>>;
     fetchRawEventByTicker(eventTicker: string): Promise<KalshiRawEvent[]>;
     private fetchRawEventsDefault;
@@ -160,6 +169,7 @@ export declare class KalshiFetcher implements IExchangeFetcher<KalshiRawEvent, K
     private enrichEventsWithSeriesMap;
     private fetchActiveEvents;
     private fetchAllWithStatus;
+    private fetchAllWithSeriesTicker;
     private fetchPageWithStatus;
 }
 export {};

package/dist/exchanges/kalshi/fetcher.js

@@ -58,6 +58,11 @@ class KalshiFetcher {
             if (params.slug) {
                 return this.fetchRawEventByTicker(params.slug);
             }
+            // When a series filter is present, delegate to server-side filtering so
+            // only events belonging to that series are returned — no double-filtering.
+            if (params.series) {
+                return this.fetchAllWithSeriesTicker(params.series);
+            }
             const status = params?.status || 'active';
             if (status === 'all') {
                 const [openEvents, closedEvents, settledEvents] = await Promise.all([
@@ -213,6 +218,15 @@ class KalshiFetcher {
         const data = await this.ctx.callApi('GetHistoricalOrders', queryParams);
         return data.orders || [];
     }
+    async fetchRawSeriesList() {
+        try {
+            const data = await this.ctx.callApi('GetSeriesList');
+            return (data.series || []);
+        }
+        catch (e) {
+            throw errors_1.kalshiErrorMapper.mapError(e);
+        }
+    }
     async fetchRawSeriesMap() {
         try {
             const data = await this.ctx.callApi('GetSeriesList');
@@ -381,6 +395,28 @@ class KalshiFetcher {
         } while (cursor && page < MAX_PAGES);
         return allEvents;
     }
+    async fetchAllWithSeriesTicker(seriesTicker) {
+        let allEvents = [];
+        let cursor = null;
+        let page = 0;
+        do {
+            const queryParams = {
+                series_ticker: seriesTicker,
+                with_nested_markets: true,
+                limit: BATCH_SIZE,
+            };
+            if (cursor)
+                queryParams.cursor = cursor;
+            const data = await this.ctx.callApi('GetEvents', queryParams);
+            const events = data.events || [];
+            if (events.length === 0)
+                break;
+            allEvents = [...allEvents, ...events];
+            cursor = data.cursor;
+            page++;
+        } while (cursor && page < MAX_PAGES);
+        return allEvents;
+    }
     async fetchPageWithStatus(apiStatus, maxEvents, initialCursor) {
         let allEvents = [];
         let cursor = initialCursor || null;