pmxtjs 2.31.3 → 2.32.1

package/dist/esm/pmxt/client.js

@@ -7,7 +7,6 @@
 import { Configuration, DefaultApi, } from "../generated/src/index.js";
 import { MarketList, } from "./models.js";
 import { ServerManager } from "./server-manager.js";
-import { buildArgsWithOptionalOptions } from "./args.js";
 import { PmxtError, fromServerError } from "./errors.js";
 import { resolvePmxtBaseUrl } from "./constants.js";
 /**
@@ -456,11 +455,8 @@ export class Exchange {
                 body: JSON.stringify({ args, credentials: this.getCredentials() }),
             });
             if (!response.ok) {
-                const body = await response.json().catch(() => ({}));
-                if (body.error && typeof body.error === "object") {
-                    throw fromServerError(body.error);
-                }
-                throw new PmxtError(body.error?.message || response.statusText);
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
             }
             const json = await response.json();
             const data = this.handleResponse(json);
@@ -471,32 +467,48 @@ export class Exchange {
             return result;
         }
         catch (error) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to loadMarkets: ${error}`);
+            throw new Error(`Failed to loadMarkets: ${error}`);
         }
     }
     async fetchMarkets(params) {
         await this.initPromise;
         try {
-            const args = buildArgsWithOptionalOptions(params);
-            const query = { ...(params || {}) };
-            const json = await this.sidecarReadRequest('fetchMarkets', query, args);
+            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.getAuthHeaders() },
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchMarkets: ${error}`);
+            throw new Error(`Failed to fetchMarkets: ${error}`);
         }
     }
     async fetchMarketsPaginated(params) {
         await this.initPromise;
         try {
-            const args = buildArgsWithOptionalOptions(params);
-            const query = { ...(params || {}) };
-            const json = await this.sidecarReadRequest('fetchMarketsPaginated', query, args);
+            const args = [];
+            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.getAuthHeaders() },
+                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: (data.data || []).map(convertMarket),
@@ -505,70 +517,120 @@ export class Exchange {
             };
         }
         catch (error) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchMarketsPaginated: ${error}`);
+            throw new Error(`Failed to fetchMarketsPaginated: ${error}`);
         }
     }
     async fetchEvents(params) {
         await this.initPromise;
         try {
-            const args = buildArgsWithOptionalOptions(params);
-            const query = { ...(params || {}) };
-            const json = await this.sidecarReadRequest('fetchEvents', query, args);
+            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.getAuthHeaders() },
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchEvents: ${error}`);
+            throw new Error(`Failed to fetchEvents: ${error}`);
         }
     }
     async fetchMarket(params) {
         await this.initPromise;
         try {
-            const args = buildArgsWithOptionalOptions(params);
-            const query = { ...(params || {}) };
-            const json = await this.sidecarReadRequest('fetchMarket', query, args);
+            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.getAuthHeaders() },
+                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 convertMarket(data);
         }
         catch (error) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchMarket: ${error}`);
+            throw new Error(`Failed to fetchMarket: ${error}`);
         }
     }
     async fetchEvent(params) {
         await this.initPromise;
         try {
-            const args = buildArgsWithOptionalOptions(params);
-            const query = { ...(params || {}) };
-            const json = await this.sidecarReadRequest('fetchEvent', query, args);
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchEvent`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                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 convertEvent(data);
         }
         catch (error) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchEvent: ${error}`);
+            throw new Error(`Failed to fetchEvent: ${error}`);
         }
     }
     async fetchOrderBook(id) {
         await this.initPromise;
-        const resolvedId = resolveOutcomeId(id);
         try {
-            const args = [resolvedId];
-            const query = { id: resolvedId };
-            const json = await this.sidecarReadRequest('fetchOrderBook', query, args);
+            const args = [];
+            args.push(id);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchOrderBook`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchOrderBook: ${error}`);
+            throw new Error(`Failed to fetchOrderBook: ${error}`);
+        }
+    }
+    async submitOrder(built) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(built);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/submitOrder`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                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 submitOrder: ${error}`);
         }
     }
     async cancelOrder(orderId) {
@@ -582,125 +644,217 @@ export class Exchange {
                 body: JSON.stringify({ args, credentials: this.getCredentials() }),
             });
             if (!response.ok) {
-                const body = await response.json().catch(() => ({}));
-                if (body.error && typeof body.error === "object") {
-                    throw fromServerError(body.error);
-                }
-                throw new PmxtError(body.error?.message || response.statusText);
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to cancelOrder: ${error}`);
+            throw new Error(`Failed to cancelOrder: ${error}`);
         }
     }
     async fetchOrder(orderId) {
         await this.initPromise;
         try {
-            const args = [orderId];
-            const query = { orderId };
-            const json = await this.sidecarReadRequest('fetchOrder', query, args);
+            const args = [];
+            args.push(orderId);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchOrder`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchOrder: ${error}`);
+            throw new Error(`Failed to fetchOrder: ${error}`);
         }
     }
     async fetchOpenOrders(marketId) {
         await this.initPromise;
         try {
-            const args = buildArgsWithOptionalOptions(marketId);
-            const query = { marketId };
-            const json = await this.sidecarReadRequest('fetchOpenOrders', query, args);
+            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.getAuthHeaders() },
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchOpenOrders: ${error}`);
+            throw new Error(`Failed to fetchOpenOrders: ${error}`);
         }
     }
     async fetchMyTrades(params) {
         await this.initPromise;
         try {
-            const args = buildArgsWithOptionalOptions(params);
-            const query = { ...(params || {}) };
-            const json = await this.sidecarReadRequest('fetchMyTrades', query, args);
+            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.getAuthHeaders() },
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchMyTrades: ${error}`);
+            throw new Error(`Failed to fetchMyTrades: ${error}`);
         }
     }
     async fetchClosedOrders(params) {
         await this.initPromise;
         try {
-            const args = buildArgsWithOptionalOptions(params);
-            const query = { ...(params || {}) };
-            const json = await this.sidecarReadRequest('fetchClosedOrders', query, args);
+            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.getAuthHeaders() },
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchClosedOrders: ${error}`);
+            throw new Error(`Failed to fetchClosedOrders: ${error}`);
         }
     }
     async fetchAllOrders(params) {
         await this.initPromise;
         try {
-            const args = buildArgsWithOptionalOptions(params);
-            const query = { ...(params || {}) };
-            const json = await this.sidecarReadRequest('fetchAllOrders', query, args);
+            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.getAuthHeaders() },
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchAllOrders: ${error}`);
+            throw new Error(`Failed to fetchAllOrders: ${error}`);
         }
     }
     async fetchPositions(address) {
         await this.initPromise;
         try {
-            const args = address ? [address] : [];
-            const query = { address };
-            const json = await this.sidecarReadRequest('fetchPositions', query, args);
+            const args = [];
+            if (address !== undefined)
+                args.push(address);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchPositions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchPositions: ${error}`);
+            throw new Error(`Failed to fetchPositions: ${error}`);
         }
     }
     async fetchBalance(address) {
         await this.initPromise;
         try {
-            const args = address ? [address] : [];
-            const query = { address };
-            const json = await this.sidecarReadRequest('fetchBalance', query, args);
+            const args = [];
+            if (address !== undefined)
+                args.push(address);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchBalance`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                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) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to fetchBalance: ${error}`);
+            throw new Error(`Failed to fetchBalance: ${error}`);
+        }
+    }
+    async unwatchOrderBook(id) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(id);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/unwatchOrderBook`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                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 unwatchOrderBook: ${error}`);
+        }
+    }
+    async unwatchAddress(address) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(address);
+            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/unwatchAddress`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                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 unwatchAddress: ${error}`);
         }
     }
     async close() {
@@ -713,19 +867,14 @@ export class Exchange {
                 body: JSON.stringify({ args, credentials: this.getCredentials() }),
             });
             if (!response.ok) {
-                const body = await response.json().catch(() => ({}));
-                if (body.error && typeof body.error === "object") {
-                    throw fromServerError(body.error);
-                }
-                throw new PmxtError(body.error?.message || response.statusText);
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
             }
             const json = await response.json();
             this.handleResponse(json);
         }
         catch (error) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to close: ${error}`);
+            throw new Error(`Failed to close: ${error}`);
         }
     }
     // END GENERATED METHODS
@@ -852,37 +1001,6 @@ export class Exchange {
             throw new PmxtError(`Failed to watch order book: ${error}`);
         }
     }
-    /**
-     * Unsubscribe from a previously watched order book stream.
-     *
-     * @param outcomeId - Outcome ID to stop watching
-     */
-    async unwatchOrderBook(outcomeId) {
-        await this.initPromise;
-        const resolvedOutcomeId = resolveOutcomeId(outcomeId);
-        try {
-            const args = [resolvedOutcomeId];
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/unwatchOrderBook`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
-                body: JSON.stringify({ args, credentials: this.getCredentials() }),
-            });
-            if (!response.ok) {
-                const body = await response.json().catch(() => ({}));
-                if (body.error && typeof body.error === "object") {
-                    throw fromServerError(body.error);
-                }
-                throw new PmxtError(body.error?.message || response.statusText);
-            }
-            const json = await response.json();
-            this.handleResponse(json);
-        }
-        catch (error) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to unwatch order book: ${error}`);
-        }
-    }
     /**
      * Watch real-time trade updates via WebSocket.
      *
@@ -992,37 +1110,6 @@ export class Exchange {
             throw new PmxtError(`Failed to watch address: ${error}`);
         }
     }
-    /**
-     * Stop watching a previously registered wallet address and release its resource updates.
-     *
-     * @param address - Public wallet to be watched
-     * @returns
-     */
-    async unwatchAddress(address) {
-        await this.initPromise;
-        try {
-            const args = [address];
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/unwatchAddress`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
-                body: JSON.stringify({ args, credentials: this.getCredentials() }),
-            });
-            if (!response.ok) {
-                const body = await response.json().catch(() => ({}));
-                if (body.error && typeof body.error === "object") {
-                    throw fromServerError(body.error);
-                }
-                throw new PmxtError(body.error?.message || response.statusText);
-            }
-            const json = await response.json();
-            return this.handleResponse(json);
-        }
-        catch (error) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to unwatch address: ${error}`);
-        }
-    }
     // Trading Methods (require authentication)
     /**
      * Build an order payload without submitting it to the exchange.
@@ -1111,50 +1198,6 @@ export class Exchange {
             throw new PmxtError(`Failed to build order: ${error}`);
         }
     }
-    /**
-     * Submit a pre-built order returned by {@link buildOrder}.
-     *
-     * @param built - The BuiltOrder payload from buildOrder()
-     * @returns The submitted order
-     *
-     * @example
-     * ```typescript
-     * const built = await exchange.buildOrder({
-     *   outcome: market.yes,
-     *   side: "buy",
-     *   type: "limit",
-     *   amount: 10,
-     *   price: 0.55
-     * });
-     * const order = await exchange.submitOrder(built);
-     * console.log(order.id, order.status);
-     * ```
-     */
-    async submitOrder(built) {
-        await this.initPromise;
-        try {
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/submitOrder`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
-                body: JSON.stringify({ args: [built], credentials: this.getCredentials() }),
-            });
-            if (!response.ok) {
-                const body = await response.json().catch(() => ({}));
-                if (body.error && typeof body.error === "object") {
-                    throw fromServerError(body.error);
-                }
-                throw new PmxtError(body.error?.message || response.statusText);
-            }
-            const json = await response.json();
-            const data = this.handleResponse(json);
-            return convertOrder(data);
-        }
-        catch (error) {
-            if (error instanceof PmxtError)
-                throw error;
-            throw new PmxtError(`Failed to submit order: ${error}`);
-        }
-    }
     /**
      * Create a new order.
      *