pmxtjs 2.9.2 → 2.9.3

package/dist/esm/pmxt/client.js

@@ -39,6 +39,7 @@ function convertMarket(raw) {
         image: raw.image,
         category: raw.category,
         tags: raw.tags,
+        eventId: raw.eventId,
         yes: convertOutcome(raw.yes),
         no: convertOutcome(raw.no),
         up: convertOutcome(raw.up),
@@ -115,9 +116,21 @@ function convertBalance(raw) {
         locked: raw.locked,
     };
 }
+function convertUserTrade(raw) {
+    return {
+        id: raw.id,
+        price: raw.price,
+        amount: raw.amount,
+        side: raw.side || "unknown",
+        timestamp: raw.timestamp,
+        orderId: raw.orderId,
+        outcomeId: raw.outcomeId,
+        marketId: raw.marketId,
+    };
+}
 function convertEvent(raw) {
     const markets = MarketList.from((raw.markets || []).map(convertMarket));
-    return {
+    const event = {
         id: raw.id,
         title: raw.title,
         description: raw.description,
@@ -128,6 +141,7 @@ function convertEvent(raw) {
         category: raw.category,
         tags: raw.tags,
     };
+    return event;
 }
 /**
  * Base class for prediction market exchanges.
@@ -206,74 +220,159 @@ export class Exchange {
             signatureType: this.signatureType,
         };
     }
-    // Market Data Methods
+    // Low-Level API Access
     /**
-     * Get active markets from the exchange.
+     * Call an exchange-specific REST endpoint by its operationId.
+     * This provides direct access to all implicit API methods defined in
+     * the exchange's OpenAPI spec (e.g., Polymarket CLOB, Kalshi trading API).
      *
-     * @param params - Optional filter parameters
-     * @returns List of unified markets
+     * @param operationId - The operationId (or auto-generated name) of the endpoint
+     * @param params - Optional parameters to pass to the endpoint
+     * @returns The raw response data from the exchange
      *
      * @example
      * ```typescript
-     * const markets = await exchange.fetchMarkets({ limit: 20, sort: "volume" });
+     * // Call a Polymarket CLOB endpoint directly
+     * const result = await poly.callApi('getMarket', { condition_id: '0x...' });
      * ```
      */
-    async fetchMarkets(params) {
+    async callApi(operationId, params) {
         await this.initPromise;
         try {
-            const args = [];
-            if (params) {
-                args.push(params);
-            }
+            const url = `${this.config.basePath}/api/${this.exchangeName}/callApi`;
             const requestBody = {
-                args,
+                args: [operationId, params],
                 credentials: this.getCredentials()
             };
-            const response = await this.api.fetchMarkets({
-                exchange: this.exchangeName,
-                fetchMarketsRequest: requestBody,
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.config.headers
+                },
+                body: JSON.stringify(requestBody)
             });
-            const data = this.handleResponse(response);
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            throw new Error(`Failed to call API '${operationId}': ${error}`);
+        }
+    }
+    // BEGIN GENERATED METHODS
+    async loadMarkets(reload = false) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(reload);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/loadMarkets`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            const result = {};
+            for (const [key, value] of Object.entries(data)) {
+                result[key] = convertMarket(value);
+            }
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to loadMarkets: ${error}`);
+        }
+    }
+    async fetchMarkets(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMarkets`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
             return data.map(convertMarket);
         }
         catch (error) {
-            throw new Error(`Failed to fetch markets: ${error}`);
+            throw new Error(`Failed to fetchMarkets: ${error}`);
         }
     }
-    /**
-     * Fetch a single market by lookup parameters.
-     * Returns the first matching market or throws if not found.
-     *
-     * @param params - Lookup parameters (marketId, outcomeId, slug, eventId, query)
-     * @returns A single unified market
-     * @throws Error if no market matches
-     *
-     * @example
-     * ```typescript
-     * const market = await exchange.fetchMarket({ marketId: '663583' });
-     * const market = await exchange.fetchMarket({ outcomeId: '10991849...' });
-     * const market = await exchange.fetchMarket({ slug: 'will-trump-win' });
-     * ```
-     */
-    async fetchMarket(params) {
+    async fetchMarketsPaginated(params) {
         await this.initPromise;
         try {
             const args = [];
-            if (params) {
+            if (params !== undefined)
                 args.push(params);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMarketsPaginated`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
             }
-            const requestBody = {
-                args,
-                credentials: this.getCredentials()
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return {
+                data: (data.data || []).map(convertMarket),
+                total: data.total,
+                nextCursor: data.nextCursor,
             };
-            const url = `${this.config.basePath}/api/${this.exchangeName}/fetchMarket`;
-            const response = await fetch(url, {
+        }
+        catch (error) {
+            throw new Error(`Failed to fetchMarketsPaginated: ${error}`);
+        }
+    }
+    async fetchEvents(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchEvents`, {
                 method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...this.config.headers
-                },
-                body: JSON.stringify(requestBody)
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return data.map(convertEvent);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetchEvents: ${error}`);
+        }
+    }
+    async fetchMarket(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMarket`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
             });
             if (!response.ok) {
                 const error = await response.json().catch(() => ({}));
@@ -284,42 +383,19 @@ export class Exchange {
             return convertMarket(data);
         }
         catch (error) {
-            throw new Error(`Failed to fetch market: ${error}`);
+            throw new Error(`Failed to fetchMarket: ${error}`);
         }
     }
-    /**
-     * Fetch a single event by lookup parameters.
-     * Returns the first matching event or throws if not found.
-     *
-     * @param params - Lookup parameters (eventId, slug, query)
-     * @returns A single unified event
-     * @throws Error if no event matches
-     *
-     * @example
-     * ```typescript
-     * const event = await exchange.fetchEvent({ eventId: 'TRUMP25DEC' });
-     * const event = await exchange.fetchEvent({ slug: 'us-election' });
-     * ```
-     */
     async fetchEvent(params) {
         await this.initPromise;
         try {
             const args = [];
-            if (params) {
+            if (params !== undefined)
                 args.push(params);
-            }
-            const requestBody = {
-                args,
-                credentials: this.getCredentials()
-            };
-            const url = `${this.config.basePath}/api/${this.exchangeName}/fetchEvent`;
-            const response = await fetch(url, {
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchEvent`, {
                 method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...this.config.headers
-                },
-                body: JSON.stringify(requestBody)
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
             });
             if (!response.ok) {
                 const error = await response.json().catch(() => ({}));
@@ -330,9 +406,230 @@ export class Exchange {
             return convertEvent(data);
         }
         catch (error) {
-            throw new Error(`Failed to fetch event: ${error}`);
+            throw new Error(`Failed to fetchEvent: ${error}`);
+        }
+    }
+    async fetchOrderBook(id) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(id);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchOrderBook`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return convertOrderBook(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetchOrderBook: ${error}`);
+        }
+    }
+    async cancelOrder(orderId) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(orderId);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/cancelOrder`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return convertOrder(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to cancelOrder: ${error}`);
+        }
+    }
+    async fetchOrder(orderId) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(orderId);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchOrder`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return convertOrder(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetchOrder: ${error}`);
+        }
+    }
+    async fetchOpenOrders(marketId) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (marketId !== undefined)
+                args.push(marketId);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchOpenOrders`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return data.map(convertOrder);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetchOpenOrders: ${error}`);
+        }
+    }
+    async fetchMyTrades(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMyTrades`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return data.map(convertUserTrade);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetchMyTrades: ${error}`);
+        }
+    }
+    async fetchClosedOrders(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchClosedOrders`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return data.map(convertOrder);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetchClosedOrders: ${error}`);
+        }
+    }
+    async fetchAllOrders(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchAllOrders`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return data.map(convertOrder);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetchAllOrders: ${error}`);
+        }
+    }
+    async fetchPositions() {
+        await this.initPromise;
+        try {
+            const args = [];
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchPositions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return data.map(convertPosition);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetchPositions: ${error}`);
         }
     }
+    async fetchBalance() {
+        await this.initPromise;
+        try {
+            const args = [];
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchBalance`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            return data.map(convertBalance);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetchBalance: ${error}`);
+        }
+    }
+    async close() {
+        await this.initPromise;
+        try {
+            const args = [];
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/close`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.config.headers },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            this.handleResponse(json);
+        }
+        catch (error) {
+            throw new Error(`Failed to close: ${error}`);
+        }
+    }
+    // END GENERATED METHODS
     /**
      * Get historical price candles.
      *
@@ -378,37 +675,6 @@ export class Exchange {
             throw new Error(`Failed to fetch OHLCV: ${error}`);
         }
     }
-    /**
-     * Get current order book for an outcome.
-     *
-     * @param outcomeId - Outcome ID
-     * @returns Current order book
-     *
-     * @example
-     * ```typescript
-     * const orderBook = await exchange.fetchOrderBook(outcomeId);
-     * console.log(`Best bid: ${orderBook.bids[0].price}`);
-     * console.log(`Best ask: ${orderBook.asks[0].price}`);
-     * ```
-     */
-    async fetchOrderBook(outcomeId) {
-        await this.initPromise;
-        try {
-            const requestBody = {
-                args: [outcomeId],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchOrderBook({
-                exchange: this.exchangeName,
-                fetchOrderBookRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return convertOrderBook(data);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch order book: ${error}`);
-        }
-    }
     /**
      * Get trade history for an outcome.
      *
@@ -594,129 +860,6 @@ export class Exchange {
             throw new Error(`Failed to create order: ${error}`);
         }
     }
-    /**
-     * Cancel an open order.
-     *
-     * @param orderId - Order ID to cancel
-     * @returns Cancelled order
-     */
-    async cancelOrder(orderId) {
-        await this.initPromise;
-        try {
-            const requestBody = {
-                args: [orderId],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.cancelOrder({
-                exchange: this.exchangeName,
-                cancelOrderRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return convertOrder(data);
-        }
-        catch (error) {
-            throw new Error(`Failed to cancel order: ${error}`);
-        }
-    }
-    /**
-     * Get details of a specific order.
-     *
-     * @param orderId - Order ID
-     * @returns Order details
-     */
-    async fetchOrder(orderId) {
-        await this.initPromise;
-        try {
-            const requestBody = {
-                args: [orderId],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchOrder({
-                exchange: this.exchangeName,
-                cancelOrderRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return convertOrder(data);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch order: ${error}`);
-        }
-    }
-    /**
-     * Get all open orders, optionally filtered by market.
-     *
-     * @param marketId - Optional market ID to filter by
-     * @returns List of open orders
-     */
-    async fetchOpenOrders(marketId) {
-        await this.initPromise;
-        try {
-            const args = [];
-            if (marketId) {
-                args.push(marketId);
-            }
-            const requestBody = {
-                args,
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchOpenOrders({
-                exchange: this.exchangeName,
-                fetchOpenOrdersRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return data.map(convertOrder);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch open orders: ${error}`);
-        }
-    }
-    // Account Methods
-    /**
-     * Get current positions across all markets.
-     *
-     * @returns List of positions
-     */
-    async fetchPositions() {
-        await this.initPromise;
-        try {
-            const requestBody = {
-                args: [],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchPositions({
-                exchange: this.exchangeName,
-                fetchPositionsRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return data.map(convertPosition);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch positions: ${error}`);
-        }
-    }
-    /**
-     * Get account balance.
-     *
-     * @returns List of balances (by currency)
-     */
-    async fetchBalance() {
-        await this.initPromise;
-        try {
-            const requestBody = {
-                args: [],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchBalance({
-                exchange: this.exchangeName,
-                fetchPositionsRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return data.map(convertBalance);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch balance: ${error}`);
-        }
-    }
     /**
      * Calculate the average execution price for a given amount by walking the order book.
      * Uses the sidecar server for calculation to ensure consistency.
@@ -1066,3 +1209,95 @@ export class Limitless extends Exchange {
         super("limitless", options);
     }
 }
+/**
+ * Kalshi Demo exchange client (paper trading / sandbox environment).
+ *
+ * Uses Kalshi's demo environment — same API as Kalshi but against test accounts.
+ * Credentials are separate from production Kalshi credentials.
+ *
+ * @example
+ * ```typescript
+ * const kalshiDemo = new KalshiDemo({
+ *   apiKey: process.env.KALSHI_DEMO_API_KEY,
+ *   privateKey: process.env.KALSHI_DEMO_PRIVATE_KEY
+ * });
+ * const balance = await kalshiDemo.fetchBalance();
+ * ```
+ */
+export class KalshiDemo extends Exchange {
+    constructor(options = {}) {
+        super("kalshi-demo", options);
+    }
+}
+/**
+ * Myriad exchange client.
+ *
+ * AMM-based prediction market exchange. Requires an API key for trading.
+ * The `privateKey` field is used as the wallet address.
+ *
+ * @example
+ * ```typescript
+ * // Public data (no auth)
+ * const myriad = new Myriad();
+ * const markets = await myriad.fetchMarkets();
+ *
+ * // Trading (requires auth)
+ * const myriad = new Myriad({
+ *   apiKey: process.env.MYRIAD_API_KEY,
+ *   privateKey: process.env.MYRIAD_WALLET_ADDRESS
+ * });
+ * ```
+ */
+export class Myriad extends Exchange {
+    constructor(options = {}) {
+        super("myriad", options);
+    }
+}
+/**
+ * Probable exchange client.
+ *
+ * BSC-based CLOB exchange. Requires all four credential fields for trading.
+ *
+ * @example
+ * ```typescript
+ * // Public data (no auth)
+ * const probable = new Probable();
+ * const markets = await probable.fetchMarkets();
+ *
+ * // Trading (requires auth)
+ * const probable = new Probable({
+ *   privateKey: process.env.PROBABLE_PRIVATE_KEY,
+ *   apiKey: process.env.PROBABLE_API_KEY,
+ *   apiSecret: process.env.PROBABLE_API_SECRET,
+ *   passphrase: process.env.PROBABLE_PASSPHRASE
+ * });
+ * ```
+ */
+export class Probable extends Exchange {
+    constructor(options = {}) {
+        super("probable", options);
+    }
+}
+/**
+ * Baozi exchange client.
+ *
+ * Solana-based on-chain pari-mutuel betting exchange.
+ * Requires a Solana private key for trading.
+ *
+ * @example
+ * ```typescript
+ * // Public data (no auth)
+ * const baozi = new Baozi();
+ * const markets = await baozi.fetchMarkets();
+ *
+ * // Trading (requires auth)
+ * const baozi = new Baozi({
+ *   privateKey: process.env.BAOZI_PRIVATE_KEY
+ * });
+ * ```
+ */
+export class Baozi extends Exchange {
+    constructor(options = {}) {
+        super("baozi", options);
+    }
+}