pmxtjs 2.34.2 → 2.35.0

package/dist/esm/pmxt/client.js

@@ -335,6 +335,51 @@ export class Exchange {
         }
         return headers;
     }
+    /**
+     * Resolve the current sidecar base URL.
+     *
+     * For hosted mode the configured basePath is returned as-is.
+     * For local mode the port is re-read from the lock file on every
+     * call so we pick up sidecar restarts that land on a different port.
+     */
+    resolveBaseUrl() {
+        if (this.isHosted)
+            return this.config.basePath;
+        const port = this.serverManager.getRunningPort();
+        return `http://localhost:${port}`;
+    }
+    /**
+     * Execute a fetch with retry on connection failures.
+     *
+     * Only retries on connection-level errors (ECONNREFUSED, ECONNRESET) —
+     * never on HTTP responses (4xx, 5xx). On first connection failure,
+     * attempts to restart the sidecar.
+     */
+    async fetchWithRetry(input, init) {
+        const delays = [200, 500, 1000];
+        let lastError;
+        for (let attempt = 0; attempt <= delays.length; attempt++) {
+            try {
+                return await fetch(input, init);
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt >= delays.length)
+                    break;
+                // Connection failed — try to restart the sidecar on first failure
+                if (attempt === 0 && !this.isHosted) {
+                    try {
+                        await this.serverManager.ensureServerRunning();
+                    }
+                    catch {
+                        // Restart failed — continue retrying anyway
+                    }
+                }
+                await new Promise(resolve => setTimeout(resolve, delays[attempt]));
+            }
+        }
+        throw lastError;
+    }
     // Low-Level API Access
     /**
      * Call an exchange-specific REST endpoint by its operationId.
@@ -354,12 +399,12 @@ export class Exchange {
     async callApi(operationId, params) {
         await this.initPromise;
         try {
-            const url = `${this.config.basePath}/api/${this.exchangeName}/callApi`;
+            const url = `${this.resolveBaseUrl()}/api/${this.exchangeName}/callApi`;
             const requestBody = {
                 args: [operationId, params],
                 credentials: this.getCredentials()
             };
-            const response = await fetch(url, {
+            const response = await this.fetchWithRetry(url, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
@@ -403,12 +448,13 @@ export class Exchange {
      * @internal — shared transport used by every generated read method.
      */
     async sidecarReadRequest(methodName, query, args) {
-        const baseUrl = `${this.config.basePath}/api/${this.exchangeName}/${methodName}`;
+        const resolvedBase = this.resolveBaseUrl();
+        const baseUrl = `${resolvedBase}/api/${this.exchangeName}/${methodName}`;
         const hasCredentials = this.getCredentials() !== undefined;
         if (!hasCredentials && !this._getReadsUnsupported && !queryHasNestedObject(query)) {
             const qs = buildSidecarQueryString(query);
             const getUrl = qs ? `${baseUrl}?${qs}` : baseUrl;
-            const response = await fetch(getUrl, {
+            const response = await this.fetchWithRetry(getUrl, {
                 method: 'GET',
                 headers: this.getAuthHeaders(),
             });
@@ -431,7 +477,7 @@ export class Exchange {
             }
         }
         // POST fallback — identical to the original per-method template.
-        const response = await fetch(baseUrl, {
+        const response = await this.fetchWithRetry(baseUrl, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
             body: JSON.stringify({ args, credentials: this.getCredentials() }),
@@ -451,14 +497,17 @@ export class Exchange {
         try {
             const args = [];
             args.push(reload);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/loadMarkets`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/loadMarkets`, {
                 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 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);
@@ -469,7 +518,9 @@ export class Exchange {
             return result;
         }
         catch (error) {
-            throw new Error(`Failed to loadMarkets: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to loadMarkets: ${error}`);
         }
     }
     async fetchMarkets(params) {
@@ -478,21 +529,26 @@ export class Exchange {
             const args = [];
             if (params !== undefined)
                 args.push(params);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMarkets`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 data.map(convertMarket);
         }
         catch (error) {
-            throw new Error(`Failed to fetchMarkets: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchMarkets: ${error}`);
         }
     }
     async fetchMarketsPaginated(params) {
@@ -501,14 +557,17 @@ export class Exchange {
             const args = [];
             if (params !== undefined)
                 args.push(params);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMarketsPaginated`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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);
@@ -519,7 +578,9 @@ export class Exchange {
             };
         }
         catch (error) {
-            throw new Error(`Failed to fetchMarketsPaginated: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchMarketsPaginated: ${error}`);
         }
     }
     async fetchEvents(params) {
@@ -528,21 +589,58 @@ export class Exchange {
             const args = [];
             if (params !== undefined)
                 args.push(params);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchEvents`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 data.map(convertEvent);
         }
         catch (error) {
-            throw new Error(`Failed to fetchEvents: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchEvents: ${error}`);
+        }
+    }
+    async fetchEventsPaginated(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchEventsPaginated`, {
+                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();
+            const data = this.handleResponse(json);
+            return {
+                data: (data.data || []).map(convertEvent),
+                total: data.total,
+                nextCursor: data.nextCursor,
+            };
+        }
+        catch (error) {
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchEventsPaginated: ${error}`);
         }
     }
     async fetchMarket(params) {
@@ -551,21 +649,26 @@ export class Exchange {
             const args = [];
             if (params !== undefined)
                 args.push(params);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMarket`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 convertMarket(data);
         }
         catch (error) {
-            throw new Error(`Failed to fetchMarket: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchMarket: ${error}`);
         }
     }
     async fetchEvent(params) {
@@ -574,21 +677,26 @@ export class Exchange {
             const args = [];
             if (params !== undefined)
                 args.push(params);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchEvent`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 convertEvent(data);
         }
         catch (error) {
-            throw new Error(`Failed to fetchEvent: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchEvent: ${error}`);
         }
     }
     async fetchOrderBook(id) {
@@ -596,21 +704,26 @@ export class Exchange {
         try {
             const args = [];
             args.push(id);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchOrderBook`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 convertOrderBook(data);
         }
         catch (error) {
-            throw new Error(`Failed to fetchOrderBook: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchOrderBook: ${error}`);
         }
     }
     async submitOrder(built) {
@@ -618,21 +731,26 @@ export class Exchange {
         try {
             const args = [];
             args.push(built);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/submitOrder`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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) {
-            throw new Error(`Failed to submitOrder: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to submitOrder: ${error}`);
         }
     }
     async cancelOrder(orderId) {
@@ -640,21 +758,26 @@ export class Exchange {
         try {
             const args = [];
             args.push(orderId);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/cancelOrder`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/cancelOrder`, {
                 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 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) {
-            throw new Error(`Failed to cancelOrder: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to cancelOrder: ${error}`);
         }
     }
     async fetchOrder(orderId) {
@@ -662,21 +785,26 @@ export class Exchange {
         try {
             const args = [];
             args.push(orderId);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchOrder`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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) {
-            throw new Error(`Failed to fetchOrder: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchOrder: ${error}`);
         }
     }
     async fetchOpenOrders(marketId) {
@@ -685,21 +813,26 @@ export class Exchange {
             const args = [];
             if (marketId !== undefined)
                 args.push(marketId);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchOpenOrders`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 data.map(convertOrder);
         }
         catch (error) {
-            throw new Error(`Failed to fetchOpenOrders: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchOpenOrders: ${error}`);
         }
     }
     async fetchMyTrades(params) {
@@ -708,21 +841,26 @@ export class Exchange {
             const args = [];
             if (params !== undefined)
                 args.push(params);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMyTrades`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 data.map(convertUserTrade);
         }
         catch (error) {
-            throw new Error(`Failed to fetchMyTrades: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchMyTrades: ${error}`);
         }
     }
     async fetchClosedOrders(params) {
@@ -731,21 +869,26 @@ export class Exchange {
             const args = [];
             if (params !== undefined)
                 args.push(params);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchClosedOrders`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 data.map(convertOrder);
         }
         catch (error) {
-            throw new Error(`Failed to fetchClosedOrders: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchClosedOrders: ${error}`);
         }
     }
     async fetchAllOrders(params) {
@@ -754,21 +897,26 @@ export class Exchange {
             const args = [];
             if (params !== undefined)
                 args.push(params);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchAllOrders`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 data.map(convertOrder);
         }
         catch (error) {
-            throw new Error(`Failed to fetchAllOrders: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchAllOrders: ${error}`);
         }
     }
     async fetchPositions(address) {
@@ -777,21 +925,26 @@ export class Exchange {
             const args = [];
             if (address !== undefined)
                 args.push(address);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchPositions`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 data.map(convertPosition);
         }
         catch (error) {
-            throw new Error(`Failed to fetchPositions: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchPositions: ${error}`);
         }
     }
     async fetchBalance(address) {
@@ -800,21 +953,26 @@ export class Exchange {
             const args = [];
             if (address !== undefined)
                 args.push(address);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchBalance`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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 data.map(convertBalance);
         }
         catch (error) {
-            throw new Error(`Failed to fetchBalance: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to fetchBalance: ${error}`);
         }
     }
     async unwatchOrderBook(id) {
@@ -822,20 +980,25 @@ export class Exchange {
         try {
             const args = [];
             args.push(id);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/unwatchOrderBook`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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) {
-            throw new Error(`Failed to unwatchOrderBook: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to unwatchOrderBook: ${error}`);
         }
     }
     async unwatchAddress(address) {
@@ -843,40 +1006,207 @@ export class Exchange {
         try {
             const args = [];
             args.push(address);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/unwatchAddress`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/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 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) {
-            throw new Error(`Failed to unwatchAddress: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to unwatchAddress: ${error}`);
         }
     }
     async close() {
         await this.initPromise;
         try {
             const args = [];
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/close`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/close`, {
                 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 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) {
-            throw new Error(`Failed to close: ${error}`);
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to close: ${error}`);
+        }
+    }
+    async fetchMarketMatches(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(params);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchMarketMatches`, {
+                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 fetchMarketMatches: ${error}`);
+        }
+    }
+    async fetchMatches(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(params);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchMatches`, {
+                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 fetchMatches: ${error}`);
+        }
+    }
+    async fetchEventMatches(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(params);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchEventMatches`, {
+                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 fetchEventMatches: ${error}`);
+        }
+    }
+    async compareMarketPrices(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(params);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/compareMarketPrices`, {
+                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 compareMarketPrices: ${error}`);
+        }
+    }
+    async fetchHedges(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(params);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchHedges`, {
+                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 fetchHedges: ${error}`);
+        }
+    }
+    async fetchArbitrage(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchArbitrage`, {
+                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 fetchArbitrage: ${error}`);
         }
     }
     // END GENERATED METHODS
@@ -981,7 +1311,7 @@ export class Exchange {
             if (limit !== undefined) {
                 args.push(limit);
             }
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/watchOrderBook`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/watchOrderBook`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
                 body: JSON.stringify({ args, credentials: this.getCredentials() }),
@@ -1040,7 +1370,7 @@ export class Exchange {
             if (limit !== undefined) {
                 args.push(limit);
             }
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/watchTrades`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/watchTrades`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
                 body: JSON.stringify({ args, credentials: this.getCredentials() }),
@@ -1090,7 +1420,7 @@ export class Exchange {
             if (types !== undefined) {
                 args.push(types);
             }
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/watchAddress`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/watchAddress`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
                 body: JSON.stringify({ args, credentials: this.getCredentials() }),
@@ -1178,7 +1508,7 @@ export class Exchange {
             if (params.fee !== undefined) {
                 paramsDict.fee = params.fee;
             }
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/buildOrder`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/buildOrder`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
                 body: JSON.stringify({ args: [paramsDict], credentials: this.getCredentials() }),
@@ -1248,7 +1578,7 @@ export class Exchange {
             if (params.fee !== undefined) {
                 paramsDict.fee = params.fee;
             }
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/createOrder`, {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/createOrder`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
                 body: JSON.stringify({ args: [paramsDict], credentials: this.getCredentials() }),
@@ -1302,8 +1632,8 @@ export class Exchange {
             if (credentials) {
                 body.credentials = credentials;
             }
-            const url = `${this.config.basePath}/api/${this.exchangeName}/getExecutionPriceDetailed`;
-            const response = await fetch(url, {
+            const url = `${this.resolveBaseUrl()}/api/${this.exchangeName}/getExecutionPriceDetailed`;
+            const response = await this.fetchWithRetry(url, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',