pmxtjs 2.34.2 → 2.35.0

package/pmxt/client.ts

@@ -29,6 +29,7 @@ import {
     OrderBook,
     OrderLevel,
     PaginatedMarketsResult,
+    PaginatedEventsResult,
     Position,
     PriceCandle,
     SubscribedAddressSnapshot,
@@ -453,6 +454,54 @@ export abstract 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.
+     */
+    private resolveBaseUrl(): string {
+        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.
+     */
+    private async fetchWithRetry(
+        input: RequestInfo | URL,
+        init?: RequestInit,
+    ): Promise<Response> {
+        const delays = [200, 500, 1000];
+        let lastError: unknown;
+
+        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
 
     /**
@@ -473,14 +522,14 @@ export abstract class Exchange {
     async callApi(operationId: string, params?: Record<string, any>): Promise<any> {
         await this.initPromise;
         try {
-            const url = `${this.config.basePath}/api/${this.exchangeName}/callApi`;
+            const url = `${this.resolveBaseUrl()}/api/${this.exchangeName}/callApi`;
 
             const requestBody: any = {
                 args: [operationId, params],
                 credentials: this.getCredentials()
             };
 
-            const response = await fetch(url, {
+            const response = await this.fetchWithRetry(url, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
@@ -529,13 +578,14 @@ export abstract class Exchange {
         query: Record<string, unknown>,
         args: unknown[],
     ): Promise<any> {
-        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(),
             });
@@ -559,7 +609,7 @@ export abstract 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() }),
@@ -581,14 +631,17 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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);
@@ -598,7 +651,8 @@ export abstract 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}`);
         }
     }
 
@@ -607,20 +661,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -629,14 +687,17 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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);
@@ -646,7 +707,8 @@ export abstract class Exchange {
                 nextCursor: data.nextCursor,
             };
         } catch (error) {
-            throw new Error(`Failed to fetchMarketsPaginated: ${error}`);
+            if (error instanceof PmxtError) throw error;
+            throw new PmxtError(`Failed to fetchMarketsPaginated: ${error}`);
         }
     }
 
@@ -655,20 +717,54 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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?: any): Promise<PaginatedEventsResult> {
+        await this.initPromise;
+        try {
+            const args: any[] = [];
+            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}`);
         }
     }
 
@@ -677,20 +773,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -699,20 +799,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -721,20 +825,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -743,20 +851,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -765,20 +877,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -787,20 +903,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -809,20 +929,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -831,20 +955,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -853,20 +981,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -875,20 +1007,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -897,20 +1033,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -919,20 +1059,24 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -941,19 +1085,23 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -962,19 +1110,23 @@ export abstract class Exchange {
         try {
             const args: any[] = [];
             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}`);
         }
     }
 
@@ -982,19 +1134,173 @@ export abstract class Exchange {
         await this.initPromise;
         try {
             const args: any[] = [];
-            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: any): Promise<any[]> {
+        await this.initPromise;
+        try {
+            const args: any[] = [];
+            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: any): Promise<any[]> {
+        await this.initPromise;
+        try {
+            const args: any[] = [];
+            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: any): Promise<any[]> {
+        await this.initPromise;
+        try {
+            const args: any[] = [];
+            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: any): Promise<any[]> {
+        await this.initPromise;
+        try {
+            const args: any[] = [];
+            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: any): Promise<any[]> {
+        await this.initPromise;
+        try {
+            const args: any[] = [];
+            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?: any): Promise<any[]> {
+        await this.initPromise;
+        try {
+            const args: any[] = [];
+            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}`);
         }
     }
 
@@ -1109,7 +1415,7 @@ export abstract class Exchange {
                 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() }),
@@ -1173,7 +1479,7 @@ export abstract class Exchange {
                 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() }),
@@ -1225,7 +1531,7 @@ export abstract 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() }),
@@ -1320,7 +1626,7 @@ export abstract class Exchange {
                 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() }),
@@ -1396,7 +1702,7 @@ export abstract class Exchange {
                 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() }),
@@ -1455,9 +1761,9 @@ export abstract class Exchange {
                 body.credentials = credentials;
             }
 
-            const url = `${this.config.basePath}/api/${this.exchangeName}/getExecutionPriceDetailed`;
+            const url = `${this.resolveBaseUrl()}/api/${this.exchangeName}/getExecutionPriceDetailed`;
 
-            const response = await fetch(url, {
+            const response = await this.fetchWithRetry(url, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',