pmxtjs 2.34.2 → 2.35.0

package/dist/pmxt/client.js

@@ -338,6 +338,51 @@ 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.
@@ -357,12 +402,12 @@ 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',
@@ -406,12 +451,13 @@ 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(),
             });
@@ -434,7 +480,7 @@ 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() }),
@@ -454,14 +500,17 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
             }
             const json = await response.json();
             const data = this.handleResponse(json);
@@ -472,7 +521,9 @@ class Exchange {
             return result;
         }
         catch (error) {
-            throw new Error(`Failed to loadMarkets: ${error}`);
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to loadMarkets: ${error}`);
         }
     }
     async fetchMarkets(params) {
@@ -481,21 +532,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchMarkets: ${error}`);
         }
     }
     async fetchMarketsPaginated(params) {
@@ -504,14 +560,17 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
             }
             const json = await response.json();
             const data = this.handleResponse(json);
@@ -522,7 +581,9 @@ class Exchange {
             };
         }
         catch (error) {
-            throw new Error(`Failed to fetchMarketsPaginated: ${error}`);
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchMarketsPaginated: ${error}`);
         }
     }
     async fetchEvents(params) {
@@ -531,21 +592,58 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchEventsPaginated: ${error}`);
         }
     }
     async fetchMarket(params) {
@@ -554,21 +652,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchMarket: ${error}`);
         }
     }
     async fetchEvent(params) {
@@ -577,21 +680,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchEvent: ${error}`);
         }
     }
     async fetchOrderBook(id) {
@@ -599,21 +707,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchOrderBook: ${error}`);
         }
     }
     async submitOrder(built) {
@@ -621,21 +734,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to submitOrder: ${error}`);
         }
     }
     async cancelOrder(orderId) {
@@ -643,21 +761,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to cancelOrder: ${error}`);
         }
     }
     async fetchOrder(orderId) {
@@ -665,21 +788,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchOrder: ${error}`);
         }
     }
     async fetchOpenOrders(marketId) {
@@ -688,21 +816,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchOpenOrders: ${error}`);
         }
     }
     async fetchMyTrades(params) {
@@ -711,21 +844,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchMyTrades: ${error}`);
         }
     }
     async fetchClosedOrders(params) {
@@ -734,21 +872,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchClosedOrders: ${error}`);
         }
     }
     async fetchAllOrders(params) {
@@ -757,21 +900,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchAllOrders: ${error}`);
         }
     }
     async fetchPositions(address) {
@@ -780,21 +928,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchPositions: ${error}`);
         }
     }
     async fetchBalance(address) {
@@ -803,21 +956,26 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchBalance: ${error}`);
         }
     }
     async unwatchOrderBook(id) {
@@ -825,20 +983,25 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to unwatchOrderBook: ${error}`);
         }
     }
     async unwatchAddress(address) {
@@ -846,40 +1009,207 @@ 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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.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 errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.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 (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchArbitrage: ${error}`);
         }
     }
     // END GENERATED METHODS
@@ -984,7 +1314,7 @@ 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() }),
@@ -1043,7 +1373,7 @@ 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() }),
@@ -1093,7 +1423,7 @@ 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() }),
@@ -1181,7 +1511,7 @@ 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() }),
@@ -1251,7 +1581,7 @@ 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() }),
@@ -1305,8 +1635,8 @@ 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',