pmxt-core 2.19.6 → 2.20.1

package/dist/BaseExchange.d.ts

@@ -1,6 +1,7 @@
-import { UnifiedMarket, UnifiedEvent, PriceCandle, CandleInterval, OrderBook, Trade, UserTrade, Order, Position, Balance, CreateOrderParams, BuiltOrder } from './types';
-import { ExecutionPriceResult } from './utils/math';
 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 { ExecutionPriceResult } from './utils/math';
 export interface ApiEndpoint {
     method: string;
     path: string;
@@ -140,6 +141,8 @@ export interface ExchangeHas {
     fetchOpenOrders: ExchangeCapability;
     fetchPositions: ExchangeCapability;
     fetchBalance: ExchangeCapability;
+    watchAddress: ExchangeCapability;
+    unwatchAddress: ExchangeCapability;
     watchOrderBook: ExchangeCapability;
     watchTrades: ExchangeCapability;
     fetchMyTrades: ExchangeCapability;
@@ -172,24 +175,28 @@ export interface PaginatedMarketsResult {
 }
 export declare abstract class PredictionMarketExchange {
     [key: string]: any;
-    protected credentials?: ExchangeCredentials;
     verbose: boolean;
     http: AxiosInstance;
     enableRateLimit: boolean;
-    private _rateLimit;
-    private _throttler;
-    private _snapshotTTL;
-    private _snapshot?;
-    get rateLimit(): number;
-    set rateLimit(value: number);
     markets: Record<string, UnifiedMarket>;
     marketsBySlug: Record<string, UnifiedMarket>;
     loadedMarkets: boolean;
+    readonly has: ExchangeHas;
+    protected credentials?: ExchangeCredentials;
     protected apiDescriptor?: ApiDescriptor;
+    private _throttler;
+    private _snapshotTTL;
+    private _snapshot?;
     private apiDescriptors;
-    readonly has: ExchangeHas;
     constructor(credentials?: ExchangeCredentials, options?: ExchangeOptions);
+    private _rateLimit;
+    get rateLimit(): number;
+    set rateLimit(value: number);
     abstract get name(): string;
+    /**
+     * Introspection getter: returns info about all implicit API methods.
+     */
+    get implicitApi(): ImplicitApiMethodInfo[];
     /**
      * Load and cache all markets from the exchange into `this.markets` and `this.marketsBySlug`.
      * Subsequent calls return the cached result without hitting the API again.
@@ -326,17 +333,6 @@ export declare abstract class PredictionMarketExchange {
      * event = exchange.fetch_event(event_id='TRUMP25DEC')
      */
     fetchEvent(params?: EventFetchParams): Promise<UnifiedEvent>;
-    /**
-     * @internal
-     * Implementation for fetching/searching markets.
-     * Exchanges should handle query, slug, and plain fetch cases based on params.
-     */
-    protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
-    /**
-     * @internal
-     * Implementation for searching events by keyword.
-     */
-    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     /**
      * Fetch historical OHLCV (candlestick) price data for a specific market outcome.
      *
@@ -562,6 +558,7 @@ export declare abstract class PredictionMarketExchange {
     /**
      * Fetch current user positions across all markets.
      *
+     * @param address - Optional public wallet address
      * @returns Array of user positions
      *
      * @example-ts Fetch positions
@@ -577,10 +574,11 @@ export declare abstract class PredictionMarketExchange {
      *     print(f"{pos.outcome_label}: {pos.size} @ ${pos.entry_price}")
      *     print(f"Unrealized P&L: ${pos.unrealized_pnl:.2f}")
      */
-    fetchPositions(): Promise<Position[]>;
+    fetchPositions(address?: string): Promise<Position[]>;
     /**
      * Fetch account balances.
      *
+     * @param address - Optional public wallet address
      * @returns Array of account balances
      *
      * @example-ts Fetch balance
@@ -591,7 +589,7 @@ export declare abstract class PredictionMarketExchange {
      * balances = exchange.fetch_balance()
      * print(f"Available: ${balances[0].available}")
      */
-    fetchBalance(): Promise<Balance[]>;
+    fetchBalance(address?: string): Promise<Balance[]>;
     /**
      * Calculate the volume-weighted average execution price for a given order size.
      * Returns 0 if the order cannot be fully filled.
@@ -720,6 +718,7 @@ export declare abstract class PredictionMarketExchange {
      * Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
      * @param id - The Outcome ID to watch
+     * @param address - Public wallet address
      * @param since - Optional timestamp to filter trades from
      * @param limit - Optional limit for number of trades
      * @returns Promise that resolves with recent trades
@@ -738,7 +737,40 @@ export declare abstract class PredictionMarketExchange {
      *     for trade in trades:
      *         print(f"{trade.side} {trade.amount} @ {trade.price}")
      */
-    watchTrades(id: string, since?: number, limit?: number): Promise<Trade[]>;
+    watchTrades(id: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
+    /**
+     * Stream activity for a public wallet address
+     * Returns a promise that resolves with the next activity snapshot whenever a change
+     * is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     *
+     * @param address - Public wallet address to watch
+     * @param types - Subset of activity to watch (default: all types)
+     * @returns Promise that resolves with the latest SubscribedAddressSnapshot snapshot
+     *
+     * @example-ts Stream wallet activity
+     * while (true) {
+     *   const activity = await exchange.watchAddress('0xabc...', ['trades', 'positions']);
+     *   console.log(activity.trades, activity.positions);
+     * }
+     *
+     * @example-python Stream wallet activity
+     * while True:
+     *     activity = exchange.watch_address('0xabc...', ['trades', 'positions'])
+     *     print(activity.trades, activity.positions)
+     */
+    watchAddress(address: string, types?: SubscriptionOption[]): Promise<SubscribedAddressSnapshot>;
+    /**
+     * Stop watching a previously registered wallet address and release its resource updates.
+     *
+     * @param address - Public wallet address to stop watching
+     *
+     * @example-ts Stop watching
+     * await exchange.unwatchAddress('0xabc...');
+     *
+     * @example-python Stop watching
+     * exchange.unwatch_address('0xabc...')
+     */
+    unwatchAddress(address: string): Promise<void>;
     /**
      * Close all WebSocket connections and clean up resources.
      * Call this when you're done streaming to properly release connections.
@@ -750,6 +782,17 @@ export declare abstract class PredictionMarketExchange {
      * exchange.close()
      */
     close(): Promise<void>;
+    /**
+     * @internal
+     * Implementation for fetching/searching markets.
+     * Exchanges should handle query, slug, and plain fetch cases based on params.
+     */
+    protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
+    /**
+     * @internal
+     * Implementation for searching events by keyword.
+     */
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     /**
      * 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
@@ -761,10 +804,6 @@ export declare abstract class PredictionMarketExchange {
      * Existing methods (unified API) are never overwritten.
      */
     protected defineImplicitApi(descriptor: ApiDescriptor): void;
-    /**
-     * Creates an async function for an implicit API endpoint.
-     */
-    private createImplicitMethod;
     /**
      * Returns auth headers for a private API call.
      * Exchanges should override this to provide authentication.
@@ -776,7 +815,7 @@ export declare abstract class PredictionMarketExchange {
      */
     protected mapImplicitApiError(error: any): any;
     /**
-     * Introspection getter: returns info about all implicit API methods.
+     * Creates an async function for an implicit API endpoint.
      */
-    get implicitApi(): ImplicitApiMethodInfo[];
+    private createImplicitMethod;
 }

package/dist/BaseExchange.js

@@ -4,41 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PredictionMarketExchange = void 0;
-const math_1 = require("./utils/math");
+const axios_1 = __importDefault(require("axios"));
 const errors_1 = require("./errors");
+const math_1 = require("./utils/math");
 const throttler_1 = require("./utils/throttler");
-const axios_1 = __importDefault(require("axios"));
 // ----------------------------------------------------------------------------
 // Base Exchange Class
 // ----------------------------------------------------------------------------
 class PredictionMarketExchange {
-    credentials;
     verbose = false;
     http;
     enableRateLimit = true;
-    _rateLimit = 1000;
-    _throttler;
-    // Snapshot state for cursor-based pagination
-    _snapshotTTL;
-    _snapshot;
-    get rateLimit() {
-        return this._rateLimit;
-    }
-    set rateLimit(value) {
-        this._rateLimit = value;
-        this._throttler = new throttler_1.Throttler({
-            refillRate: 1 / value,
-            capacity: 1,
-            delay: 1,
-        });
-    }
     // Market Cache
     markets = {};
     marketsBySlug = {};
     loadedMarkets = false;
-    // Implicit API (merged across multiple defineImplicitApi calls)
-    apiDescriptor;
-    apiDescriptors = [];
     has = {
         fetchMarkets: false,
         fetchEvents: false,
@@ -51,6 +31,8 @@ class PredictionMarketExchange {
         fetchOpenOrders: false,
         fetchPositions: false,
         fetchBalance: false,
+        watchAddress: false,
+        unwatchAddress: false,
         watchOrderBook: false,
         watchTrades: false,
         fetchMyTrades: false,
@@ -59,6 +41,14 @@ class PredictionMarketExchange {
         buildOrder: false,
         submitOrder: false,
     };
+    credentials;
+    // Implicit API (merged across multiple defineImplicitApi calls)
+    apiDescriptor;
+    _throttler;
+    // Snapshot state for cursor-based pagination
+    _snapshotTTL;
+    _snapshot;
+    apiDescriptors = [];
     constructor(credentials, options) {
         this.credentials = credentials;
         this._snapshotTTL = options?.snapshotTTL ?? 0;
@@ -94,7 +84,7 @@ class PredictionMarketExchange {
         this.http.interceptors.response.use((response) => {
             if (this.verbose) {
                 console.log(`\n[pmxt] ← ${response.status} ${response.statusText} ${response.config.url}`);
-                // console.log('[pmxt] response:', JSON.stringify(response.data, null, 2)); 
+                // console.log('[pmxt] response:', JSON.stringify(response.data, null, 2));
                 // Commented out full body log to avoid spam, but headers might be useful
             }
             return response;
@@ -110,6 +100,31 @@ class PredictionMarketExchange {
             return Promise.reject(error);
         });
     }
+    _rateLimit = 1000;
+    get rateLimit() {
+        return this._rateLimit;
+    }
+    set rateLimit(value) {
+        this._rateLimit = value;
+        this._throttler = new throttler_1.Throttler({
+            refillRate: 1 / value,
+            capacity: 1,
+            delay: 1,
+        });
+    }
+    /**
+     * Introspection getter: returns info about all implicit API methods.
+     */
+    get implicitApi() {
+        if (!this.apiDescriptor)
+            return [];
+        return Object.entries(this.apiDescriptor.endpoints).map(([name, endpoint]) => ({
+            name,
+            method: endpoint.method,
+            path: endpoint.path,
+            isPrivate: !!endpoint.isPrivate,
+        }));
+    }
     /**
      * Load and cache all markets from the exchange into `this.markets` and `this.marketsBySlug`.
      * Subsequent calls return the cached result without hitting the API again.
@@ -303,6 +318,9 @@ class PredictionMarketExchange {
         }
         return markets[0];
     }
+    // ----------------------------------------------------------------------------
+    // Implementation methods (to be overridden by exchanges)
+    // ----------------------------------------------------------------------------
     /**
      * Fetch a single event by lookup parameters.
      * Convenience wrapper around fetchEvents() that returns a single result or throws EventNotFound.
@@ -325,24 +343,6 @@ class PredictionMarketExchange {
         }
         return events[0];
     }
-    // ----------------------------------------------------------------------------
-    // Implementation methods (to be overridden by exchanges)
-    // ----------------------------------------------------------------------------
-    /**
-     * @internal
-     * Implementation for fetching/searching markets.
-     * Exchanges should handle query, slug, and plain fetch cases based on params.
-     */
-    async fetchMarketsImpl(params) {
-        throw new Error("Method fetchMarketsImpl not implemented.");
-    }
-    /**
-     * @internal
-     * Implementation for searching events by keyword.
-     */
-    async fetchEventsImpl(params) {
-        throw new Error("Method fetchEventsImpl not implemented.");
-    }
     /**
      * Fetch historical OHLCV (candlestick) price data for a specific market outcome.
      *
@@ -422,9 +422,6 @@ class PredictionMarketExchange {
         }
         throw new Error("Method fetchTrades not implemented.");
     }
-    // ----------------------------------------------------------------------------
-    // Trading Methods
-    // ----------------------------------------------------------------------------
     /**
      * Place a new order on the exchange.
      *
@@ -474,6 +471,9 @@ class PredictionMarketExchange {
     async createOrder(params) {
         throw new Error("Method createOrder not implemented.");
     }
+    // ----------------------------------------------------------------------------
+    // Trading Methods
+    // ----------------------------------------------------------------------------
     /**
      * Build an order payload without submitting it to the exchange.
      * Returns the exchange-native signed order or request body for inspection,
@@ -507,7 +507,7 @@ class PredictionMarketExchange {
      * order = exchange.submit_order(built)
      */
     async buildOrder(params) {
-        throw new Error("Method buildOrder not implemented.");
+        throw new Error('Method buildOrder not implemented.');
     }
     /**
      * Submit a pre-built order returned by buildOrder().
@@ -526,7 +526,7 @@ class PredictionMarketExchange {
      * print(f"Order {order.id}: {order.status}")
      */
     async submitOrder(built) {
-        throw new Error("Method submitOrder not implemented.");
+        throw new Error('Method submitOrder not implemented.');
     }
     /**
      * Cancel an existing open order.
@@ -600,6 +600,7 @@ class PredictionMarketExchange {
     /**
      * Fetch current user positions across all markets.
      *
+     * @param address - Optional public wallet address
      * @returns Array of user positions
      *
      * @example-ts Fetch positions
@@ -615,12 +616,13 @@ class PredictionMarketExchange {
      *     print(f"{pos.outcome_label}: {pos.size} @ ${pos.entry_price}")
      *     print(f"Unrealized P&L: ${pos.unrealized_pnl:.2f}")
      */
-    async fetchPositions() {
+    async fetchPositions(address) {
         throw new Error("Method fetchPositions not implemented.");
     }
     /**
      * Fetch account balances.
      *
+     * @param address - Optional public wallet address
      * @returns Array of account balances
      *
      * @example-ts Fetch balance
@@ -631,7 +633,7 @@ class PredictionMarketExchange {
      * balances = exchange.fetch_balance()
      * print(f"Available: ${balances[0].available}")
      */
-    async fetchBalance() {
+    async fetchBalance(address) {
         throw new Error("Method fetchBalance not implemented.");
     }
     /**
@@ -681,9 +683,6 @@ class PredictionMarketExchange {
     getExecutionPriceDetailed(orderBook, side, amount) {
         return (0, math_1.getExecutionPriceDetailed)(orderBook, side, amount);
     }
-    // ----------------------------------------------------------------------------
-    // Filtering Methods
-    // ----------------------------------------------------------------------------
     /**
      * Filter a list of markets by criteria.
      * Can filter by string query, structured criteria object, or custom filter function.
@@ -847,6 +846,9 @@ class PredictionMarketExchange {
             return true;
         });
     }
+    // ----------------------------------------------------------------------------
+    // Filtering Methods
+    // ----------------------------------------------------------------------------
     /**
      * Filter a list of events by criteria.
      * Can filter by string query, structured criteria object, or custom filter function.
@@ -938,9 +940,6 @@ class PredictionMarketExchange {
             return true;
         });
     }
-    // ----------------------------------------------------------------------------
-    // WebSocket Streaming Methods
-    // ----------------------------------------------------------------------------
     /**
      * Watch order book updates in real-time via WebSocket.
      * Returns a promise that resolves with the next order book update. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
@@ -963,11 +962,15 @@ class PredictionMarketExchange {
     async watchOrderBook(id, limit) {
         throw new Error(`watchOrderBook() is not supported by ${this.name}`);
     }
+    // ----------------------------------------------------------------------------
+    // WebSocket Streaming Methods
+    // ----------------------------------------------------------------------------
     /**
      * Watch trade executions in real-time via WebSocket.
      * Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
      * @param id - The Outcome ID to watch
+     * @param address - Public wallet address
      * @param since - Optional timestamp to filter trades from
      * @param limit - Optional limit for number of trades
      * @returns Promise that resolves with recent trades
@@ -986,9 +989,46 @@ class PredictionMarketExchange {
      *     for trade in trades:
      *         print(f"{trade.side} {trade.amount} @ {trade.price}")
      */
-    async watchTrades(id, since, limit) {
+    async watchTrades(id, address, since, limit) {
         throw new Error(`watchTrades() is not supported by ${this.name}`);
     }
+    /**
+     * Stream activity for a public wallet address
+     * Returns a promise that resolves with the next activity snapshot whenever a change
+     * is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     *
+     * @param address - Public wallet address to watch
+     * @param types - Subset of activity to watch (default: all types)
+     * @returns Promise that resolves with the latest SubscribedAddressSnapshot snapshot
+     *
+     * @example-ts Stream wallet activity
+     * while (true) {
+     *   const activity = await exchange.watchAddress('0xabc...', ['trades', 'positions']);
+     *   console.log(activity.trades, activity.positions);
+     * }
+     *
+     * @example-python Stream wallet activity
+     * while True:
+     *     activity = exchange.watch_address('0xabc...', ['trades', 'positions'])
+     *     print(activity.trades, activity.positions)
+     */
+    async watchAddress(address, types) {
+        throw new Error(`watchAddress() is not supported by ${this.name}`);
+    }
+    /**
+     * Stop watching a previously registered wallet address and release its resource updates.
+     *
+     * @param address - Public wallet address to stop watching
+     *
+     * @example-ts Stop watching
+     * await exchange.unwatchAddress('0xabc...');
+     *
+     * @example-python Stop watching
+     * exchange.unwatch_address('0xabc...')
+     */
+    async unwatchAddress(address) {
+        throw new Error(`unwatchAddress() is not supported by ${this.name}`);
+    }
     /**
      * Close all WebSocket connections and clean up resources.
      * Call this when you're done streaming to properly release connections.
@@ -1003,9 +1043,24 @@ class PredictionMarketExchange {
         // Default implementation: no-op
         // Exchanges with WebSocket support should override this
     }
+    /**
+     * @internal
+     * Implementation for fetching/searching markets.
+     * Exchanges should handle query, slug, and plain fetch cases based on params.
+     */
+    async fetchMarketsImpl(params) {
+        throw new Error("Method fetchMarketsImpl not implemented.");
+    }
     // ----------------------------------------------------------------------------
     // Implicit API (OpenAPI-driven method generation)
     // ----------------------------------------------------------------------------
+    /**
+     * @internal
+     * Implementation for searching events by keyword.
+     */
+    async fetchEventsImpl(params) {
+        throw new Error("Method fetchEventsImpl not implemented.");
+    }
     /**
      * 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
@@ -1039,6 +1094,20 @@ class PredictionMarketExchange {
             this[name] = this.createImplicitMethod(name, endpoint, descriptor.baseUrl);
         }
     }
+    /**
+     * Returns auth headers for a private API call.
+     * Exchanges should override this to provide authentication.
+     */
+    sign(_method, _path, _params) {
+        return {};
+    }
+    /**
+     * Maps errors from implicit API calls through the exchange's error mapper.
+     * Exchanges should override this to use their specific error mapper.
+     */
+    mapImplicitApiError(error) {
+        throw error;
+    }
     /**
      * Creates an async function for an implicit API endpoint.
      */
@@ -1089,32 +1158,5 @@ class PredictionMarketExchange {
             }
         };
     }
-    /**
-     * Returns auth headers for a private API call.
-     * Exchanges should override this to provide authentication.
-     */
-    sign(_method, _path, _params) {
-        return {};
-    }
-    /**
-     * Maps errors from implicit API calls through the exchange's error mapper.
-     * Exchanges should override this to use their specific error mapper.
-     */
-    mapImplicitApiError(error) {
-        throw error;
-    }
-    /**
-     * Introspection getter: returns info about all implicit API methods.
-     */
-    get implicitApi() {
-        if (!this.apiDescriptor)
-            return [];
-        return Object.entries(this.apiDescriptor.endpoints).map(([name, endpoint]) => ({
-            name,
-            method: endpoint.method,
-            path: endpoint.path,
-            isPrivate: !!endpoint.isPrivate,
-        }));
-    }
 }
 exports.PredictionMarketExchange = PredictionMarketExchange;

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

@@ -17,6 +17,8 @@ export declare class BaoziExchange extends PredictionMarketExchange {
         fetchOpenOrders: "emulated";
         fetchPositions: true;
         fetchBalance: true;
+        watchAddress: false;
+        unwatchAddress: false;
         watchOrderBook: true;
         watchTrades: false;
         fetchMyTrades: false;

package/dist/exchanges/baozi/index.js

@@ -26,6 +26,8 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchOpenOrders: 'emulated',
         fetchPositions: true,
         fetchBalance: true,
+        watchAddress: false,
+        unwatchAddress: false,
         watchOrderBook: true,
         watchTrades: false,
         fetchMyTrades: false,

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

@@ -0,0 +1,3 @@
+import { MarketOutcome } from "../../types";
+export declare function clampBaoziPrice(value: number): number;
+export declare function normalizeBaoziOutcomes(outcomes: MarketOutcome[]): void;

package/dist/exchanges/baozi/price.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clampBaoziPrice = clampBaoziPrice;
+exports.normalizeBaoziOutcomes = normalizeBaoziOutcomes;
+function clampBaoziPrice(value) {
+    return Math.min(Math.max(value, 0), 1);
+}
+function normalizeBaoziOutcomes(outcomes) {
+    const sum = outcomes.reduce((acc, item) => acc + item.price, 0);
+    if (sum <= 0) {
+        return;
+    }
+    for (const outcome of outcomes) {
+        outcome.price = outcome.price / sum;
+    }
+}

package/dist/exchanges/baozi/price.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/exchanges/baozi/price.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const price_1 = require("./price");
+describe("clampBaoziPrice", () => {
+    test("clamps values below 0 to 0", () => {
+        expect((0, price_1.clampBaoziPrice)(-0.1)).toBe(0);
+    });
+    test("clamps values above 1 to 1", () => {
+        expect((0, price_1.clampBaoziPrice)(1.2)).toBe(1);
+    });
+    test("leaves values in range unchanged", () => {
+        expect((0, price_1.clampBaoziPrice)(0.3)).toBe(0.3);
+        expect((0, price_1.clampBaoziPrice)(0)).toBe(0);
+        expect((0, price_1.clampBaoziPrice)(1)).toBe(1);
+    });
+});
+describe("normalizeBaoziOutcomes", () => {
+    function makeOutcome(price) {
+        return { outcomeId: "x", marketId: "m", label: "X", price };
+    }
+    test("normalizes prices to sum to 1", () => {
+        const outcomes = [makeOutcome(2), makeOutcome(3)];
+        (0, price_1.normalizeBaoziOutcomes)(outcomes);
+        expect(outcomes[0].price).toBeCloseTo(0.4);
+        expect(outcomes[1].price).toBeCloseTo(0.6);
+    });
+    test("does nothing when sum is zero", () => {
+        const outcomes = [makeOutcome(0), makeOutcome(0)];
+        (0, price_1.normalizeBaoziOutcomes)(outcomes);
+        expect(outcomes[0].price).toBe(0);
+        expect(outcomes[1].price).toBe(0);
+    });
+});