pmxt-core 2.4.0 → 2.6.0

package/dist/BaseExchange.d.ts

@@ -8,6 +8,9 @@ export interface MarketFilterParams {
     searchIn?: 'title' | 'description' | 'both';
     query?: string;
     slug?: string;
+    marketId?: string;
+    outcomeId?: string;
+    eventId?: string;
     page?: number;
     similarityThreshold?: number;
 }
@@ -19,6 +22,8 @@ export interface EventFetchParams {
     offset?: number;
     status?: 'active' | 'inactive' | 'closed' | 'all';
     searchIn?: 'title' | 'description' | 'both';
+    eventId?: string;
+    slug?: string;
 }
 export interface HistoryFilterParams {
     resolution?: CandleInterval;
@@ -89,6 +94,22 @@ export type EventFilterCriteria = {
     };
 };
 export type EventFilterFunction = (event: UnifiedEvent) => boolean;
+export type ExchangeCapability = true | false | 'emulated';
+export interface ExchangeHas {
+    fetchMarkets: ExchangeCapability;
+    fetchEvents: ExchangeCapability;
+    fetchOHLCV: ExchangeCapability;
+    fetchOrderBook: ExchangeCapability;
+    fetchTrades: ExchangeCapability;
+    createOrder: ExchangeCapability;
+    cancelOrder: ExchangeCapability;
+    fetchOrder: ExchangeCapability;
+    fetchOpenOrders: ExchangeCapability;
+    fetchPositions: ExchangeCapability;
+    fetchBalance: ExchangeCapability;
+    watchOrderBook: ExchangeCapability;
+    watchTrades: ExchangeCapability;
+}
 export interface ExchangeCredentials {
     apiKey?: string;
     apiSecret?: string;
@@ -99,6 +120,7 @@ export interface ExchangeCredentials {
 }
 export declare abstract class PredictionMarketExchange {
     protected credentials?: ExchangeCredentials;
+    readonly has: ExchangeHas;
     constructor(credentials?: ExchangeCredentials);
     abstract get name(): string;
     /**
@@ -155,6 +177,39 @@ export declare abstract class PredictionMarketExchange {
      * print(fed_event.title, len(fed_event.markets), 'markets')
      */
     fetchEvents(params?: EventFetchParams): Promise<UnifiedEvent[]>;
+    /**
+     * Fetch a single market by lookup parameters.
+     * Convenience wrapper around fetchMarkets() that returns a single result or throws MarketNotFound.
+     *
+     * @param params - Lookup parameters (marketId, outcomeId, slug, etc.)
+     * @returns A single unified market
+     * @throws MarketNotFound if no market matches the parameters
+     *
+     * @example-ts Fetch by market ID
+     * const market = await exchange.fetchMarket({ marketId: '663583' });
+     *
+     * @example-ts Fetch by outcome ID
+     * const market = await exchange.fetchMarket({ outcomeId: '10991849...' });
+     *
+     * @example-python Fetch by market ID
+     * market = exchange.fetch_market(market_id='663583')
+     */
+    fetchMarket(params?: MarketFetchParams): Promise<UnifiedMarket>;
+    /**
+     * Fetch a single event by lookup parameters.
+     * Convenience wrapper around fetchEvents() that returns a single result or throws EventNotFound.
+     *
+     * @param params - Lookup parameters (eventId, slug, query)
+     * @returns A single unified event
+     * @throws EventNotFound if no event matches the parameters
+     *
+     * @example-ts Fetch by event ID
+     * const event = await exchange.fetchEvent({ eventId: 'TRUMP25DEC' });
+     *
+     * @example-python Fetch by event ID
+     * event = exchange.fetch_event(event_id='TRUMP25DEC')
+     */
+    fetchEvent(params?: EventFetchParams): Promise<UnifiedEvent>;
     /**
      * @internal
      * Implementation for fetching/searching markets.

package/dist/BaseExchange.js

@@ -2,11 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PredictionMarketExchange = void 0;
 const math_1 = require("./utils/math");
+const errors_1 = require("./errors");
 // ----------------------------------------------------------------------------
 // Base Exchange Class
 // ----------------------------------------------------------------------------
 class PredictionMarketExchange {
     credentials;
+    has = {
+        fetchMarkets: false,
+        fetchEvents: false,
+        fetchOHLCV: false,
+        fetchOrderBook: false,
+        fetchTrades: false,
+        createOrder: false,
+        cancelOrder: false,
+        fetchOrder: false,
+        fetchOpenOrders: false,
+        fetchPositions: false,
+        fetchBalance: false,
+        watchOrderBook: false,
+        watchTrades: false,
+    };
     constructor(credentials) {
         this.credentials = credentials;
     }
@@ -66,11 +82,58 @@ class PredictionMarketExchange {
      * print(fed_event.title, len(fed_event.markets), 'markets')
      */
     async fetchEvents(params) {
-        if (!params?.query) {
-            throw new Error("fetchEvents() requires a query parameter");
+        if (!params?.query && !params?.eventId && !params?.slug) {
+            throw new Error("fetchEvents() requires a query, eventId, or slug parameter");
         }
         return this.fetchEventsImpl(params);
     }
+    /**
+     * Fetch a single market by lookup parameters.
+     * Convenience wrapper around fetchMarkets() that returns a single result or throws MarketNotFound.
+     *
+     * @param params - Lookup parameters (marketId, outcomeId, slug, etc.)
+     * @returns A single unified market
+     * @throws MarketNotFound if no market matches the parameters
+     *
+     * @example-ts Fetch by market ID
+     * const market = await exchange.fetchMarket({ marketId: '663583' });
+     *
+     * @example-ts Fetch by outcome ID
+     * const market = await exchange.fetchMarket({ outcomeId: '10991849...' });
+     *
+     * @example-python Fetch by market ID
+     * market = exchange.fetch_market(market_id='663583')
+     */
+    async fetchMarket(params) {
+        const markets = await this.fetchMarkets(params);
+        if (markets.length === 0) {
+            const identifier = params?.marketId || params?.outcomeId || params?.slug || params?.eventId || params?.query || 'unknown';
+            throw new errors_1.MarketNotFound(identifier, this.name);
+        }
+        return markets[0];
+    }
+    /**
+     * Fetch a single event by lookup parameters.
+     * Convenience wrapper around fetchEvents() that returns a single result or throws EventNotFound.
+     *
+     * @param params - Lookup parameters (eventId, slug, query)
+     * @returns A single unified event
+     * @throws EventNotFound if no event matches the parameters
+     *
+     * @example-ts Fetch by event ID
+     * const event = await exchange.fetchEvent({ eventId: 'TRUMP25DEC' });
+     *
+     * @example-python Fetch by event ID
+     * event = exchange.fetch_event(event_id='TRUMP25DEC')
+     */
+    async fetchEvent(params) {
+        const events = await this.fetchEvents(params);
+        if (events.length === 0) {
+            const identifier = params?.eventId || params?.slug || params?.query || 'unknown';
+            throw new errors_1.EventNotFound(identifier, this.name);
+        }
+        return events[0];
+    }
     // ----------------------------------------------------------------------------
     // Implementation methods (to be overridden by exchanges)
     // ----------------------------------------------------------------------------

package/dist/errors.d.ts

@@ -51,6 +51,12 @@ export declare class OrderNotFound extends BaseError {
 export declare class MarketNotFound extends BaseError {
     constructor(marketId: string, exchange?: string);
 }
+/**
+ * 404 Not Found - The requested event doesn't exist
+ */
+export declare class EventNotFound extends BaseError {
+    constructor(identifier: string, exchange?: string);
+}
 /**
  * 429 Too Many Requests - Rate limit exceeded
  */

package/dist/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExchangeNotAvailable = exports.NetworkError = exports.ValidationError = exports.InsufficientFunds = exports.InvalidOrder = exports.RateLimitExceeded = exports.MarketNotFound = exports.OrderNotFound = exports.NotFound = exports.PermissionDenied = exports.AuthenticationError = exports.BadRequest = exports.BaseError = void 0;
+exports.ExchangeNotAvailable = exports.NetworkError = exports.ValidationError = exports.InsufficientFunds = exports.InvalidOrder = exports.RateLimitExceeded = exports.EventNotFound = exports.MarketNotFound = exports.OrderNotFound = exports.NotFound = exports.PermissionDenied = exports.AuthenticationError = exports.BadRequest = exports.BaseError = void 0;
 /**
  * Base error class for all PMXT errors
  *
@@ -87,6 +87,15 @@ class MarketNotFound extends BaseError {
     }
 }
 exports.MarketNotFound = MarketNotFound;
+/**
+ * 404 Not Found - The requested event doesn't exist
+ */
+class EventNotFound extends BaseError {
+    constructor(identifier, exchange) {
+        super(`Event not found: ${identifier}`, 404, 'EVENT_NOT_FOUND', false, exchange);
+    }
+}
+exports.EventNotFound = EventNotFound;
 /**
  * 429 Too Many Requests - Rate limit exceeded
  */

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

@@ -0,0 +1,14 @@
+import { Keypair, PublicKey, Transaction } from '@solana/web3.js';
+import { ExchangeCredentials } from '../../BaseExchange';
+/**
+ * Manages Solana wallet authentication for Baozi.
+ * Read operations don't need auth (all on-chain data is public).
+ * Write operations (betting, claiming) require a Solana keypair.
+ */
+export declare class BaoziAuth {
+    private keypair;
+    constructor(credentials: ExchangeCredentials);
+    getPublicKey(): PublicKey;
+    getKeypair(): Keypair;
+    signTransaction(tx: Transaction): Transaction;
+}

package/dist/exchanges/baozi/auth.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaoziAuth = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+/**
+ * Manages Solana wallet authentication for Baozi.
+ * Read operations don't need auth (all on-chain data is public).
+ * Write operations (betting, claiming) require a Solana keypair.
+ */
+class BaoziAuth {
+    keypair;
+    constructor(credentials) {
+        if (!credentials.privateKey) {
+            throw new Error('Baozi requires a privateKey (base58-encoded Solana secret key) for trading operations');
+        }
+        this.keypair = web3_js_1.Keypair.fromSecretKey(bs58_1.default.decode(credentials.privateKey));
+    }
+    getPublicKey() {
+        return this.keypair.publicKey;
+    }
+    getKeypair() {
+        return this.keypair;
+    }
+    signTransaction(tx) {
+        tx.sign(this.keypair);
+        return tx;
+    }
+}
+exports.BaoziAuth = BaoziAuth;

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

@@ -0,0 +1,11 @@
+import { ErrorMapper } from '../../utils/error-mapper';
+import { BaseError } from '../../errors';
+/**
+ * Maps Solana/Anchor errors to pmxt unified error types.
+ */
+export declare class BaoziErrorMapper extends ErrorMapper {
+    constructor();
+    mapError(error: any): BaseError;
+    private extractAnchorError;
+}
+export declare const baoziErrorMapper: BaoziErrorMapper;

package/dist/exchanges/baozi/errors.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baoziErrorMapper = exports.BaoziErrorMapper = void 0;
+const error_mapper_1 = require("../../utils/error-mapper");
+const errors_1 = require("../../errors");
+// Anchor/Baozi program error codes
+const PROGRAM_ERRORS = {
+    6000: { type: 'bad_request', message: 'Unauthorized' },
+    6001: { type: 'bad_request', message: 'Market not found' },
+    6015: { type: 'bad_request', message: 'Market is not open for betting' },
+    6018: { type: 'bad_request', message: 'Betting is closed' },
+    6020: { type: 'invalid_order', message: 'Bet amount too small' },
+    6040: { type: 'bad_request', message: 'Betting is frozen' },
+    6041: { type: 'invalid_order', message: 'Bet amount too large' },
+};
+/**
+ * Maps Solana/Anchor errors to pmxt unified error types.
+ */
+class BaoziErrorMapper extends error_mapper_1.ErrorMapper {
+    constructor() {
+        super('Baozi');
+    }
+    mapError(error) {
+        // Handle Solana transaction errors
+        if (error?.message) {
+            const msg = error.message;
+            // Solana insufficient funds
+            if (msg.includes('Attempt to debit an account but found no record of a prior credit') ||
+                msg.includes('insufficient lamports') ||
+                msg.includes('insufficient funds')) {
+                return new errors_1.InsufficientFunds('Insufficient SOL balance', 'Baozi');
+            }
+            // Solana network errors
+            if (msg.includes('failed to send transaction') ||
+                msg.includes('Node is behind') ||
+                msg.includes('Transaction simulation failed')) {
+                // Try to extract Anchor error code
+                const anchorError = this.extractAnchorError(msg);
+                if (anchorError) {
+                    return anchorError;
+                }
+                return new errors_1.NetworkError(`Solana RPC error: ${msg}`, 'Baozi');
+            }
+            // Connection errors
+            if (msg.includes('ECONNREFUSED') || msg.includes('ETIMEDOUT') || msg.includes('fetch failed')) {
+                return new errors_1.ExchangeNotAvailable('Solana RPC unreachable', 'Baozi');
+            }
+        }
+        return super.mapError(error);
+    }
+    extractAnchorError(message) {
+        // Anchor errors appear as "custom program error: 0x{hex}"
+        const match = message.match(/custom program error: 0x([0-9a-fA-F]+)/);
+        if (!match)
+            return null;
+        const code = parseInt(match[1], 16);
+        const knownError = PROGRAM_ERRORS[code];
+        if (!knownError) {
+            return new errors_1.BadRequest(`Baozi program error ${code}: ${message}`, 'Baozi');
+        }
+        switch (knownError.type) {
+            case 'invalid_order':
+                return new errors_1.InvalidOrder(knownError.message, 'Baozi');
+            default:
+                return new errors_1.BadRequest(knownError.message, 'Baozi');
+        }
+    }
+}
+exports.BaoziErrorMapper = BaoziErrorMapper;
+exports.baoziErrorMapper = new BaoziErrorMapper();

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

@@ -0,0 +1,8 @@
+import { Connection } from '@solana/web3.js';
+import { EventFetchParams } from '../../BaseExchange';
+import { UnifiedEvent } from '../../types';
+/**
+ * Baozi doesn't have Kalshi-style "events" (groups of related markets).
+ * Each market IS an event. Simple 1:1 mapping.
+ */
+export declare function fetchEvents(connection: Connection, params: EventFetchParams): Promise<UnifiedEvent[]>;

package/dist/exchanges/baozi/fetchEvents.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchEvents = fetchEvents;
+const fetchMarkets_1 = require("./fetchMarkets");
+const errors_1 = require("./errors");
+/**
+ * Baozi doesn't have Kalshi-style "events" (groups of related markets).
+ * Each market IS an event. Simple 1:1 mapping.
+ */
+async function fetchEvents(connection, params) {
+    try {
+        const markets = await (0, fetchMarkets_1.fetchMarkets)(connection, {
+            query: params.query,
+            limit: params.limit,
+            offset: params.offset,
+            status: params.status,
+            searchIn: params.searchIn,
+        });
+        return markets.map(m => ({
+            id: m.marketId,
+            title: m.title,
+            description: m.description,
+            slug: m.marketId,
+            markets: [m],
+            url: m.url,
+            image: m.image,
+            category: m.category,
+            tags: m.tags,
+        }));
+    }
+    catch (error) {
+        throw errors_1.baoziErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,5 @@
+import { Connection } from '@solana/web3.js';
+import { MarketFetchParams } from '../../BaseExchange';
+import { UnifiedMarket } from '../../types';
+export declare function fetchMarkets(connection: Connection, params?: MarketFetchParams): Promise<UnifiedMarket[]>;
+export declare function fetchSingleMarket(connection: Connection, pubkey: string): Promise<UnifiedMarket | null>;

package/dist/exchanges/baozi/fetchMarkets.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchMarkets = fetchMarkets;
+exports.fetchSingleMarket = fetchSingleMarket;
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+const marketsCache = new utils_1.Cache(30_000); // 30s TTL
+async function fetchMarkets(connection, params) {
+    try {
+        // Use cache for default (no-filter) fetches
+        if (!params?.query && !params?.slug) {
+            const cached = marketsCache.get();
+            if (cached) {
+                return applyFilters(cached, params);
+            }
+        }
+        // Fetch boolean and race markets in parallel
+        const [booleanAccounts, raceAccounts] = await Promise.all([
+            connection.getProgramAccounts(utils_1.PROGRAM_ID, {
+                filters: [{ memcmp: { offset: 0, bytes: utils_1.MARKET_DISCRIMINATOR_BS58 } }],
+            }),
+            connection.getProgramAccounts(utils_1.PROGRAM_ID, {
+                filters: [{ memcmp: { offset: 0, bytes: utils_1.RACE_MARKET_DISCRIMINATOR_BS58 } }],
+            }),
+        ]);
+        const markets = [];
+        // Parse boolean markets
+        for (const account of booleanAccounts) {
+            try {
+                const parsed = (0, utils_1.parseMarket)(account.account.data);
+                markets.push((0, utils_1.mapBooleanToUnified)(parsed, account.pubkey.toString()));
+            }
+            catch {
+                // Skip malformed accounts
+            }
+        }
+        // Parse race markets
+        for (const account of raceAccounts) {
+            try {
+                const parsed = (0, utils_1.parseRaceMarket)(account.account.data);
+                markets.push((0, utils_1.mapRaceToUnified)(parsed, account.pubkey.toString()));
+            }
+            catch {
+                // Skip malformed accounts
+            }
+        }
+        // Cache results
+        marketsCache.set(markets);
+        return applyFilters(markets, params);
+    }
+    catch (error) {
+        throw errors_1.baoziErrorMapper.mapError(error);
+    }
+}
+async function fetchSingleMarket(connection, pubkey) {
+    try {
+        const { PublicKey } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        const pk = new PublicKey(pubkey);
+        const accountInfo = await connection.getAccountInfo(pk);
+        if (!accountInfo)
+            return null;
+        const data = accountInfo.data;
+        const discriminator = data.subarray(0, 8);
+        // Check if it's a boolean market
+        if (Buffer.from(discriminator).equals(Buffer.from([219, 190, 213, 55, 0, 227, 198, 154]))) {
+            const parsed = (0, utils_1.parseMarket)(data);
+            return (0, utils_1.mapBooleanToUnified)(parsed, pubkey);
+        }
+        // Check if it's a race market
+        if (Buffer.from(discriminator).equals(Buffer.from([235, 196, 111, 75, 230, 113, 118, 238]))) {
+            const parsed = (0, utils_1.parseRaceMarket)(data);
+            return (0, utils_1.mapRaceToUnified)(parsed, pubkey);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function applyFilters(markets, params) {
+    let result = [...markets];
+    // Status filter
+    const status = params?.status || 'active';
+    if (status !== 'all') {
+        const now = Date.now();
+        if (status === 'active') {
+            result = result.filter(m => m.resolutionDate.getTime() > now);
+        }
+        else {
+            // 'inactive' / 'closed'
+            result = result.filter(m => m.resolutionDate.getTime() <= now);
+        }
+    }
+    // Text search
+    if (params?.query) {
+        const lowerQuery = params.query.toLowerCase();
+        const searchIn = params.searchIn || 'title';
+        result = result.filter(m => {
+            const titleMatch = m.title.toLowerCase().includes(lowerQuery);
+            const descMatch = (m.description || '').toLowerCase().includes(lowerQuery);
+            if (searchIn === 'title')
+                return titleMatch;
+            if (searchIn === 'description')
+                return descMatch;
+            return titleMatch || descMatch; // 'both'
+        });
+    }
+    // Sort
+    if (params?.sort === 'volume') {
+        result.sort((a, b) => (b.volume || 0) - (a.volume || 0));
+    }
+    else if (params?.sort === 'liquidity') {
+        result.sort((a, b) => b.liquidity - a.liquidity);
+    }
+    else if (params?.sort === 'newest') {
+        result.sort((a, b) => b.resolutionDate.getTime() - a.resolutionDate.getTime());
+    }
+    else {
+        // Default: sort by volume
+        result.sort((a, b) => (b.volume || 0) - (a.volume || 0));
+    }
+    // Pagination
+    const offset = params?.offset || 0;
+    const limit = params?.limit || 10000;
+    result = result.slice(offset, offset + limit);
+    return result;
+}

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

@@ -0,0 +1,6 @@
+import { PriceCandle } from '../../types';
+/**
+ * Baozi has no historical price/trade API without a custom indexer.
+ * Returns an empty array.
+ */
+export declare function fetchOHLCV(): Promise<PriceCandle[]>;

package/dist/exchanges/baozi/fetchOHLCV.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOHLCV = fetchOHLCV;
+/**
+ * Baozi has no historical price/trade API without a custom indexer.
+ * Returns an empty array.
+ */
+async function fetchOHLCV() {
+    return [];
+}

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

@@ -0,0 +1,12 @@
+import { Connection } from '@solana/web3.js';
+import { OrderBook } from '../../types';
+/**
+ * Pari-mutuel markets don't have a real order book.
+ * We synthesize one that represents the current pool state:
+ * - bid = ask = implied probability from pool ratios
+ * - size = total pool in SOL
+ *
+ * This honestly represents pari-mutuel: there's one "price"
+ * (the implied probability) and you can bet any amount into it.
+ */
+export declare function fetchOrderBook(connection: Connection, outcomeId: string): Promise<OrderBook>;

package/dist/exchanges/baozi/fetchOrderBook.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOrderBook = fetchOrderBook;
+const fetchMarkets_1 = require("./fetchMarkets");
+const errors_1 = require("./errors");
+/**
+ * Pari-mutuel markets don't have a real order book.
+ * We synthesize one that represents the current pool state:
+ * - bid = ask = implied probability from pool ratios
+ * - size = total pool in SOL
+ *
+ * This honestly represents pari-mutuel: there's one "price"
+ * (the implied probability) and you can bet any amount into it.
+ */
+async function fetchOrderBook(connection, outcomeId) {
+    try {
+        const marketPubkey = outcomeId.replace(/-YES$|-NO$|-\d+$/, '');
+        const market = await (0, fetchMarkets_1.fetchSingleMarket)(connection, marketPubkey);
+        if (!market) {
+            throw new Error(`Market not found: ${marketPubkey}`);
+        }
+        // Find the outcome matching the requested ID
+        const outcome = market.outcomes.find(o => o.outcomeId === outcomeId);
+        const price = outcome?.price ?? 0.5;
+        const totalLiquidity = market.liquidity;
+        // Single price level representing the entire pool
+        return {
+            bids: [{ price, size: totalLiquidity }],
+            asks: [{ price, size: totalLiquidity }],
+            timestamp: Date.now(),
+        };
+    }
+    catch (error) {
+        throw errors_1.baoziErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,6 @@
+import { Trade } from '../../types';
+/**
+ * Baozi has no trade history API without a custom indexer.
+ * Returns an empty array.
+ */
+export declare function fetchTrades(): Promise<Trade[]>;

package/dist/exchanges/baozi/fetchTrades.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTrades = fetchTrades;
+/**
+ * Baozi has no trade history API without a custom indexer.
+ * Returns an empty array.
+ */
+async function fetchTrades() {
+    return [];
+}