@chainflip/rpc 1.8.7 → 1.8.8

package/dist/Client.cjs

@@ -1,41 +1,72 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;// src/Client.ts
-var _assertion = require('@chainflip/utils/assertion');
-
+var _async = require('@chainflip/utils/async');
 
 
 var _commoncjs = require('./common.cjs');
 var Client = (_class = class {
-  constructor(url) {;_class.prototype.__init.call(this);
+  constructor(url) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
     this.url = url;
   }
   __init() {this.lastRequestId = 0}
+  __init2() {this.timer = null}
+  __init3() {this.requestMap = /* @__PURE__ */ new Map()}
   getRequestId() {
-    return String(++this.lastRequestId);
+    try {
+      return crypto.randomUUID();
+    } catch (e) {
+      return String(++this.lastRequestId);
+    }
   }
   formatRequest(method, params) {
     return { jsonrpc: "2.0", id: this.getRequestId(), method, params };
   }
-  parseSingleResponse(response) {
+  handleResponse(response, clonedMap) {
+    const clonedItem = clonedMap.get(response.id);
+    if (!clonedItem) return;
+    clonedMap.delete(response.id);
     if (!response.success) {
-      throw response.error;
-    }
-    const parseResult = _commoncjs.rpcResponse.safeParse(response.result);
-    if (!parseResult.success) {
-      throw new Error("Malformed RPC response received");
+      return clonedItem.deferred.reject(response.error);
     }
-    if ("error" in parseResult.data) {
-      throw new Error(
-        `RPC error [${parseResult.data.error.code}]: ${parseResult.data.error.message}`
+    const rpcResponse = response.result;
+    if ("error" in rpcResponse) {
+      return clonedItem.deferred.reject(
+        new Error(`RPC error [${rpcResponse.error.code}]: ${rpcResponse.error.message}`)
       );
     }
-    _assertion.assert.call(void 0, "result" in parseResult.data);
-    return parseResult.data;
-  }
-  async sendRequest(method, ...params) {
-    const [response] = await this.send([this.formatRequest(method, params)]);
-    if (!response.success) throw response.error;
-    const parseResult = this.parseSingleResponse(response);
-    return _commoncjs.rpcResult[method].parse(parseResult.result);
+    const parseResult = _commoncjs.rpcResult[clonedItem.method].safeParse(rpcResponse.result);
+    if (parseResult.error) {
+      return clonedItem.deferred.reject(parseResult.error);
+    }
+    clonedItem.deferred.resolve(parseResult.data);
+  }
+  handleErrorResponse(error, clonedMap) {
+    for (const [id] of clonedMap) {
+      this.handleResponse({ id, success: false, error }, clonedMap);
+    }
+  }
+  async handleBatch() {
+    const clonedMap = new Map(this.requestMap);
+    this.requestMap.clear();
+    const requests = [...clonedMap.values()].map((item) => item.body);
+    await this.send(requests, clonedMap);
+    clonedMap.forEach((item) => {
+      item.deferred.reject(new Error("Could not find the result for the request"));
+    });
+  }
+  sendRequest(method, ...params) {
+    if (!_commoncjs.rpcResult[method]) {
+      return Promise.reject(new Error(`Unknown method: ${method}`));
+    }
+    const deferred = _async.deferredPromise.call(void 0, );
+    const body = this.formatRequest(method, params);
+    this.requestMap.set(body.id, { deferred, body, method });
+    if (!this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = null;
+        void this.handleBatch();
+      }, 0);
+    }
+    return deferred.promise;
   }
   methods() {
     return Object.keys(_commoncjs.rpcResult).sort();

package/dist/Client.d.cts

@@ -1,4 +1,5 @@
-import { RpcMethod, JsonRpcRequest, RpcRequest, RpcResult } from './common.cjs';
+import { DeferredPromise } from '@chainflip/utils/async';
+import { RpcMethod, JsonRpcRequest, RpcResult, JsonRpcResponse, RpcRequest } from './common.cjs';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.cjs';
@@ -6,26 +7,31 @@ import './parsers.cjs';
 type Response = {
     success: true;
     id: string;
-    result: unknown;
+    result: JsonRpcResponse;
 } | {
     success: false;
     id: string;
     error: Error;
 };
+type RequestMap = Map<string, {
+    deferred: DeferredPromise<RpcResult<RpcMethod>>;
+    body: JsonRpcRequest<RpcMethod>;
+    method: RpcMethod;
+}>;
 declare abstract class Client {
     protected readonly url: string;
     private lastRequestId;
+    private timer;
+    private requestMap;
     constructor(url: string);
-    protected abstract send<const T extends RpcMethod>(data: JsonRpcRequest<T>[]): Promise<Response[]>;
-    protected getRequestId(): string;
-    protected formatRequest<T extends RpcMethod>(method: T, params: RpcRequest[T]): JsonRpcRequest<T>;
-    protected parseSingleResponse(response: Response): {
-        id: string | number;
-        jsonrpc: "2.0";
-        result?: any;
-    };
+    protected abstract send<const T extends RpcMethod>(data: JsonRpcRequest<T>[], clonedMap: RequestMap): Promise<void>;
+    private getRequestId;
+    private formatRequest;
+    protected handleResponse(response: Response, clonedMap: RequestMap): void;
+    protected handleErrorResponse(error: Error, clonedMap: RequestMap): void;
+    private handleBatch;
     sendRequest<const T extends RpcMethod>(method: T, ...params: RpcRequest[T]): Promise<RpcResult<T>>;
     methods(): RpcMethod[];
 }
 
-export { type Response, Client as default };
+export { type RequestMap, type Response, Client as default };

package/dist/Client.d.ts

@@ -1,4 +1,5 @@
-import { RpcMethod, JsonRpcRequest, RpcRequest, RpcResult } from './common.js';
+import { DeferredPromise } from '@chainflip/utils/async';
+import { RpcMethod, JsonRpcRequest, RpcResult, JsonRpcResponse, RpcRequest } from './common.js';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.js';
@@ -6,26 +7,31 @@ import './parsers.js';
 type Response = {
     success: true;
     id: string;
-    result: unknown;
+    result: JsonRpcResponse;
 } | {
     success: false;
     id: string;
     error: Error;
 };
+type RequestMap = Map<string, {
+    deferred: DeferredPromise<RpcResult<RpcMethod>>;
+    body: JsonRpcRequest<RpcMethod>;
+    method: RpcMethod;
+}>;
 declare abstract class Client {
     protected readonly url: string;
     private lastRequestId;
+    private timer;
+    private requestMap;
     constructor(url: string);
-    protected abstract send<const T extends RpcMethod>(data: JsonRpcRequest<T>[]): Promise<Response[]>;
-    protected getRequestId(): string;
-    protected formatRequest<T extends RpcMethod>(method: T, params: RpcRequest[T]): JsonRpcRequest<T>;
-    protected parseSingleResponse(response: Response): {
-        id: string | number;
-        jsonrpc: "2.0";
-        result?: any;
-    };
+    protected abstract send<const T extends RpcMethod>(data: JsonRpcRequest<T>[], clonedMap: RequestMap): Promise<void>;
+    private getRequestId;
+    private formatRequest;
+    protected handleResponse(response: Response, clonedMap: RequestMap): void;
+    protected handleErrorResponse(error: Error, clonedMap: RequestMap): void;
+    private handleBatch;
     sendRequest<const T extends RpcMethod>(method: T, ...params: RpcRequest[T]): Promise<RpcResult<T>>;
     methods(): RpcMethod[];
 }
 
-export { type Response, Client as default };
+export { type RequestMap, type Response, Client as default };

package/dist/Client.mjs

@@ -1,41 +1,72 @@
 // src/Client.ts
-import { assert } from "@chainflip/utils/assertion";
+import { deferredPromise } from "@chainflip/utils/async";
 import {
-  rpcResult,
-  rpcResponse
+  rpcResult
 } from "./common.mjs";
 var Client = class {
   constructor(url) {
     this.url = url;
   }
   lastRequestId = 0;
+  timer = null;
+  requestMap = /* @__PURE__ */ new Map();
   getRequestId() {
-    return String(++this.lastRequestId);
+    try {
+      return crypto.randomUUID();
+    } catch {
+      return String(++this.lastRequestId);
+    }
   }
   formatRequest(method, params) {
     return { jsonrpc: "2.0", id: this.getRequestId(), method, params };
   }
-  parseSingleResponse(response) {
+  handleResponse(response, clonedMap) {
+    const clonedItem = clonedMap.get(response.id);
+    if (!clonedItem) return;
+    clonedMap.delete(response.id);
     if (!response.success) {
-      throw response.error;
-    }
-    const parseResult = rpcResponse.safeParse(response.result);
-    if (!parseResult.success) {
-      throw new Error("Malformed RPC response received");
+      return clonedItem.deferred.reject(response.error);
     }
-    if ("error" in parseResult.data) {
-      throw new Error(
-        `RPC error [${parseResult.data.error.code}]: ${parseResult.data.error.message}`
+    const rpcResponse = response.result;
+    if ("error" in rpcResponse) {
+      return clonedItem.deferred.reject(
+        new Error(`RPC error [${rpcResponse.error.code}]: ${rpcResponse.error.message}`)
       );
     }
-    assert("result" in parseResult.data);
-    return parseResult.data;
-  }
-  async sendRequest(method, ...params) {
-    const [response] = await this.send([this.formatRequest(method, params)]);
-    if (!response.success) throw response.error;
-    const parseResult = this.parseSingleResponse(response);
-    return rpcResult[method].parse(parseResult.result);
+    const parseResult = rpcResult[clonedItem.method].safeParse(rpcResponse.result);
+    if (parseResult.error) {
+      return clonedItem.deferred.reject(parseResult.error);
+    }
+    clonedItem.deferred.resolve(parseResult.data);
+  }
+  handleErrorResponse(error, clonedMap) {
+    for (const [id] of clonedMap) {
+      this.handleResponse({ id, success: false, error }, clonedMap);
+    }
+  }
+  async handleBatch() {
+    const clonedMap = new Map(this.requestMap);
+    this.requestMap.clear();
+    const requests = [...clonedMap.values()].map((item) => item.body);
+    await this.send(requests, clonedMap);
+    clonedMap.forEach((item) => {
+      item.deferred.reject(new Error("Could not find the result for the request"));
+    });
+  }
+  sendRequest(method, ...params) {
+    if (!rpcResult[method]) {
+      return Promise.reject(new Error(`Unknown method: ${method}`));
+    }
+    const deferred = deferredPromise();
+    const body = this.formatRequest(method, params);
+    this.requestMap.set(body.id, { deferred, body, method });
+    if (!this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = null;
+        void this.handleBatch();
+      }, 0);
+    }
+    return deferred.promise;
   }
   methods() {
     return Object.keys(rpcResult).sort();

package/dist/HttpClient.cjs

@@ -1,13 +1,7 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } var _class;// src/HttpClient.ts
-var _async = require('@chainflip/utils/async');
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/HttpClient.ts
 var _Clientcjs = require('./Client.cjs'); var _Clientcjs2 = _interopRequireDefault(_Clientcjs);
-
-
-var _commoncjs = require('./common.cjs');
-var HttpClient = (_class = class extends _Clientcjs2.default {constructor(...args) { super(...args); _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
-  __init() {this.timer = null}
-  __init2() {this.requestMap = /* @__PURE__ */ new Map()}
-  async send(request) {
+var HttpClient = class extends _Clientcjs2.default {
+  async send(request, requestMap) {
     let res;
     try {
       res = await fetch(this.url, {
@@ -18,70 +12,23 @@ var HttpClient = (_class = class extends _Clientcjs2.default {constructor(...arg
         }
       });
     } catch (error) {
-      return request.map((r) => ({
-        id: r.id,
-        success: false,
-        error: new Error("Network error", { cause: error })
-      }));
+      this.handleErrorResponse(new Error("Network error", { cause: error }), requestMap);
+      return;
     }
     if (!res.ok) {
-      return request.map((r) => ({
-        id: r.id,
-        success: false,
-        error: new Error(`HTTP error: ${res.status}`)
-      }));
+      this.handleErrorResponse(new Error(`HTTP error: ${res.status}`), requestMap);
+      return;
     }
     try {
       const jsonRpcResponse = await res.json();
-      return jsonRpcResponse.map((r) => ({ id: r.id, success: true, result: r }));
-    } catch (cause) {
-      return request.map((r) => ({
-        id: r.id,
-        success: false,
-        error: new Error("Invalid JSON response", { cause })
-      }));
-    }
-  }
-  sendRequest(method, ...params) {
-    const deferred = _async.deferredPromise.call(void 0, );
-    const body = this.formatRequest(method, params);
-    this.requestMap.set(body.id, { deferred, body, method });
-    if (!this.timer) {
-      this.timer = setTimeout(() => {
-        this.timer = null;
-        void this.sendBatch();
-      }, 0);
-    }
-    return deferred.promise;
-  }
-  async sendBatch() {
-    const clonedMap = new Map(this.requestMap);
-    this.requestMap.clear();
-    const requests = [...clonedMap.values()].map((item) => item.body);
-    const responses = await this.send(requests);
-    for (const response of responses) {
-      const clonedItem = clonedMap.get(response.id);
-      if (!clonedItem) {
-        continue;
-      }
-      if (!response.success) {
-        clonedItem.deferred.reject(response.error);
-        continue;
-      }
-      try {
-        const parseResult = this.parseSingleResponse(response);
-        clonedItem.deferred.resolve(_commoncjs.rpcResult[clonedItem.method].parse(parseResult.result));
-      } catch (e) {
-        clonedItem.deferred.reject(e);
-      } finally {
-        clonedMap.delete(response.id);
+      for (const r of jsonRpcResponse) {
+        this.handleResponse({ id: r.id, success: true, result: r }, requestMap);
       }
+    } catch (cause) {
+      this.handleErrorResponse(new Error("Invalid JSON response", { cause }), requestMap);
     }
-    clonedMap.forEach((item) => {
-      item.deferred.reject(new Error("Could not find the result for the request"));
-    });
   }
-}, _class);
+};
 
 
 exports.default = HttpClient;

package/dist/HttpClient.d.cts

@@ -1,15 +1,12 @@
-import Client, { Response } from './Client.cjs';
-import { RpcMethod, JsonRpcRequest, RpcRequest, RpcResult } from './common.cjs';
+import Client, { RequestMap } from './Client.cjs';
+import { RpcMethod, JsonRpcRequest } from './common.cjs';
+import '@chainflip/utils/async';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.cjs';
 
 declare class HttpClient extends Client {
-    private timer;
-    private requestMap;
-    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>[]): Promise<Response[]>;
-    sendRequest<const T extends RpcMethod>(method: T, ...params: RpcRequest[T]): Promise<RpcResult<T>>;
-    private sendBatch;
+    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>[], requestMap: RequestMap): Promise<void>;
 }
 
 export { HttpClient as default };

package/dist/HttpClient.d.ts

@@ -1,15 +1,12 @@
-import Client, { Response } from './Client.js';
-import { RpcMethod, JsonRpcRequest, RpcRequest, RpcResult } from './common.js';
+import Client, { RequestMap } from './Client.js';
+import { RpcMethod, JsonRpcRequest } from './common.js';
+import '@chainflip/utils/async';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.js';
 
 declare class HttpClient extends Client {
-    private timer;
-    private requestMap;
-    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>[]): Promise<Response[]>;
-    sendRequest<const T extends RpcMethod>(method: T, ...params: RpcRequest[T]): Promise<RpcResult<T>>;
-    private sendBatch;
+    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>[], requestMap: RequestMap): Promise<void>;
 }
 
 export { HttpClient as default };

package/dist/HttpClient.mjs

@@ -1,13 +1,7 @@
 // src/HttpClient.ts
-import { deferredPromise } from "@chainflip/utils/async";
 import Client from "./Client.mjs";
-import {
-  rpcResult
-} from "./common.mjs";
 var HttpClient = class extends Client {
-  timer = null;
-  requestMap = /* @__PURE__ */ new Map();
-  async send(request) {
+  async send(request, requestMap) {
     let res;
     try {
       res = await fetch(this.url, {
@@ -18,68 +12,21 @@ var HttpClient = class extends Client {
         }
       });
     } catch (error) {
-      return request.map((r) => ({
-        id: r.id,
-        success: false,
-        error: new Error("Network error", { cause: error })
-      }));
+      this.handleErrorResponse(new Error("Network error", { cause: error }), requestMap);
+      return;
     }
     if (!res.ok) {
-      return request.map((r) => ({
-        id: r.id,
-        success: false,
-        error: new Error(`HTTP error: ${res.status}`)
-      }));
+      this.handleErrorResponse(new Error(`HTTP error: ${res.status}`), requestMap);
+      return;
     }
     try {
       const jsonRpcResponse = await res.json();
-      return jsonRpcResponse.map((r) => ({ id: r.id, success: true, result: r }));
-    } catch (cause) {
-      return request.map((r) => ({
-        id: r.id,
-        success: false,
-        error: new Error("Invalid JSON response", { cause })
-      }));
-    }
-  }
-  sendRequest(method, ...params) {
-    const deferred = deferredPromise();
-    const body = this.formatRequest(method, params);
-    this.requestMap.set(body.id, { deferred, body, method });
-    if (!this.timer) {
-      this.timer = setTimeout(() => {
-        this.timer = null;
-        void this.sendBatch();
-      }, 0);
-    }
-    return deferred.promise;
-  }
-  async sendBatch() {
-    const clonedMap = new Map(this.requestMap);
-    this.requestMap.clear();
-    const requests = [...clonedMap.values()].map((item) => item.body);
-    const responses = await this.send(requests);
-    for (const response of responses) {
-      const clonedItem = clonedMap.get(response.id);
-      if (!clonedItem) {
-        continue;
-      }
-      if (!response.success) {
-        clonedItem.deferred.reject(response.error);
-        continue;
-      }
-      try {
-        const parseResult = this.parseSingleResponse(response);
-        clonedItem.deferred.resolve(rpcResult[clonedItem.method].parse(parseResult.result));
-      } catch (e) {
-        clonedItem.deferred.reject(e);
-      } finally {
-        clonedMap.delete(response.id);
+      for (const r of jsonRpcResponse) {
+        this.handleResponse({ id: r.id, success: true, result: r }, requestMap);
       }
+    } catch (cause) {
+      this.handleErrorResponse(new Error("Invalid JSON response", { cause }), requestMap);
     }
-    clonedMap.forEach((item) => {
-      item.deferred.reject(new Error("Could not find the result for the request"));
-    });
   }
 };
 export {

package/dist/WsClient.cjs

@@ -1,111 +1,124 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/WsClient.ts
 var _async = require('@chainflip/utils/async');
+var _zod = require('zod');
 var _Clientcjs = require('./Client.cjs'); var _Clientcjs2 = _interopRequireDefault(_Clientcjs);
 var _commoncjs = require('./common.cjs');
+var CONNECTING = "CONNECTING";
 var READY = "READY";
 var DISCONNECT = "DISCONNECT";
 var WsClient = (_class = class extends _Clientcjs2.default {
-  constructor(url, WebSocket = globalThis.WebSocket) {
-    super(url);_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);;
-    this.WebSocket = WebSocket;
-  }
   
   __init() {this.reconnectAttempts = 0}
   __init2() {this.emitter = new EventTarget()}
-  __init3() {this.requestMap = /* @__PURE__ */ new Map()}
-  async close() {
-    await this.handleClose();
+  __init3() {this.inFlightRequestMap = /* @__PURE__ */ new Map()}
+  
+  __init4() {this.shouldConnect = true}
+  constructor(url, { timeout = 3e4 } = {}) {
+    super(url);_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);;
+    this.timeout = timeout;
   }
-  async handleClose() {
+  async close() {
+    this.shouldConnect = false;
     if (!this.ws) return;
-    this.ws.removeEventListener("close", this.handleDisconnect);
+    await this.handleDisconnect();
+    const waitForClose = this.ws.readyState === WebSocket.OPEN;
     this.ws.close();
-    if (this.ws.readyState !== this.WebSocket.CLOSED) {
-      await _async.once.call(void 0, this.ws, "close");
-    }
+    if (waitForClose) await _async.once.call(void 0, this.ws, "close");
+    this.ws = void 0;
   }
   async connectionReady() {
     if (!this.ws) {
       return this.connect();
     }
-    if (this.ws.readyState !== this.WebSocket.OPEN) {
+    if (this.ws.readyState !== WebSocket.OPEN) {
       await _async.once.call(void 0, this.emitter, READY, { timeout: 3e4 });
     }
     return this.ws;
   }
-  __init4() {this.handleDisconnect = async () => {
+  __init5() {this.handleDisconnect = async () => {
     this.emitter.dispatchEvent(new Event(DISCONNECT));
-    this.requestMap.forEach((request) => {
+    this.inFlightRequestMap.forEach((request) => {
       request.reject(new Error("disconnected"));
     });
-    this.requestMap.clear();
+    this.inFlightRequestMap.clear();
+    if (!this.shouldConnect) return;
     const backoff = 250 * 2 ** this.reconnectAttempts;
     await _async.sleep.call(void 0, backoff);
     await this.connect().catch(() => {
       this.reconnectAttempts = Math.min(this.reconnectAttempts + 1, 6);
     });
   }}
-  __init5() {this.handleMessage = (data) => {
+  __init6() {this.handleMessage = (data) => {
     const parsedData = JSON.parse(data.data);
-    const response = _commoncjs.rpcResponse.safeParse(parsedData);
-    if (!response.success) return;
-    const { id } = response.data;
-    _optionalChain([this, 'access', _6 => _6.requestMap, 'access', _7 => _7.get, 'call', _8 => _8(id), 'optionalAccess', _9 => _9.resolve, 'call', _10 => _10(response.data)]);
+    const responses = _zod.z.array(_commoncjs.rpcResponse).safeParse(parsedData);
+    if (!responses.success) return;
+    for (const response of responses.data) {
+      const { id } = response;
+      _optionalChain([this, 'access', _6 => _6.inFlightRequestMap, 'access', _7 => _7.get, 'call', _8 => _8(id), 'optionalAccess', _9 => _9.resolve, 'call', _10 => _10(response)]);
+    }
   }}
   async connect() {
-    const socket = new this.WebSocket(this.url);
+    this.shouldConnect = true;
+    this.emitter.dispatchEvent(new Event(CONNECTING));
+    const socket = new WebSocket(this.url);
     this.ws = socket;
     this.ws.addEventListener("message", this.handleMessage);
+    let connected = false;
+    const handleConnectionError = () => {
+      if (!connected) {
+        void this.handleDisconnect();
+      }
+    };
     this.ws.addEventListener("close", this.handleDisconnect, { once: true });
-    await _async.once.call(void 0, this.ws, "open", { timeout: 3e4 });
+    this.ws.addEventListener("error", handleConnectionError, { once: true });
+    await _async.once.call(void 0, this.ws, "open", { timeout: this.timeout });
+    connected = true;
     this.ws.addEventListener("error", () => {
       socket.close();
     });
     this.emitter.dispatchEvent(new Event(READY));
+    this.ws.removeEventListener("error", handleConnectionError);
     this.reconnectAttempts = 0;
     return socket;
   }
-  async send(requests) {
-    const responses = [];
-    for (const data of requests) {
-      const MAX_RETRIES = 5;
-      for (let i = 0; i < MAX_RETRIES; i += 1) {
-        let socket;
-        try {
-          socket = await this.connectionReady();
-        } catch (e) {
-          continue;
-        }
-        socket.send(JSON.stringify(data));
-        const request = _async.deferredPromise.call(void 0, );
-        this.requestMap.set(data.id, request);
-        const controller = new AbortController();
-        const result = await Promise.race([
-          _async.sleep.call(void 0, 3e4, { signal: controller.signal }).then(
-            () => ({ success: false, retry: false, error: new Error("timeout") })
+  async send(requests, requestMap) {
+    const MAX_RETRIES = 5;
+    let socket;
+    for (let i = 0; i < MAX_RETRIES; i += 1) {
+      try {
+        socket = await this.connectionReady();
+      } catch (e) {
+        continue;
+      }
+    }
+    if (!socket) {
+      this.handleErrorResponse(new Error("failed to connect"), requestMap);
+      return;
+    }
+    socket.send(JSON.stringify(requests));
+    const promises = [];
+    for (const [id] of requestMap) {
+      const result = _async.deferredPromise.call(void 0, );
+      const controller = new AbortController();
+      this.inFlightRequestMap.set(id, result);
+      promises.push(
+        Promise.race([
+          _async.sleep.call(void 0, this.timeout, { signal: controller.signal }).then(
+            () => ({ id, success: false, error: new Error("timeout") })
           ),
-          request.promise.then(
-            (r) => ({ success: true, result: r }),
-            (error) => ({ success: false, error, retry: true })
+          result.promise.then(
+            (r) => ({ id, success: true, result: r }),
+            (error) => ({ id, success: false, error })
           )
-        ]).finally(() => {
-          this.requestMap.delete(data.id);
+        ]).then((response) => {
+          this.handleResponse(response, requestMap);
+        }).finally(() => {
+          this.inFlightRequestMap.delete(id);
           controller.abort();
-        });
-        if (result.success || !result.retry) {
-          responses.push({ ...result, id: data.id });
-          break;
-        }
-        if (i === MAX_RETRIES - 1) {
-          responses.push({
-            success: false,
-            error: new Error("max retries exceeded"),
-            id: data.id
-          });
-        }
-      }
+        })
+      );
     }
-    return responses;
+    await Promise.all(promises);
   }
 }, _class);
 

package/dist/WsClient.d.cts

@@ -1,23 +1,26 @@
-import Client, { Response } from './Client.cjs';
-import { RpcMethod, JsonRpcRequest } from './common.cjs';
+import Client, { RequestMap } from './Client.cjs';
+import { JsonRpcRequest, RpcMethod } from './common.cjs';
+import '@chainflip/utils/async';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.cjs';
 
 declare class WsClient extends Client {
-    private readonly WebSocket;
     private ws?;
     private reconnectAttempts;
     private emitter;
-    private requestMap;
-    constructor(url: string, WebSocket?: typeof globalThis.WebSocket);
+    private inFlightRequestMap;
+    private readonly timeout;
+    private shouldConnect;
+    constructor(url: string, { timeout }?: {
+        timeout?: number;
+    });
     close(): Promise<void>;
-    private handleClose;
     private connectionReady;
     private handleDisconnect;
     private handleMessage;
     private connect;
-    protected send<const T extends RpcMethod>(requests: JsonRpcRequest<T>[]): Promise<Response[]>;
+    protected send(requests: JsonRpcRequest<RpcMethod>[], requestMap: RequestMap): Promise<void>;
 }
 
 export { WsClient as default };

package/dist/WsClient.d.ts

@@ -1,23 +1,26 @@
-import Client, { Response } from './Client.js';
-import { RpcMethod, JsonRpcRequest } from './common.js';
+import Client, { RequestMap } from './Client.js';
+import { JsonRpcRequest, RpcMethod } from './common.js';
+import '@chainflip/utils/async';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.js';
 
 declare class WsClient extends Client {
-    private readonly WebSocket;
     private ws?;
     private reconnectAttempts;
     private emitter;
-    private requestMap;
-    constructor(url: string, WebSocket?: typeof globalThis.WebSocket);
+    private inFlightRequestMap;
+    private readonly timeout;
+    private shouldConnect;
+    constructor(url: string, { timeout }?: {
+        timeout?: number;
+    });
     close(): Promise<void>;
-    private handleClose;
     private connectionReady;
     private handleDisconnect;
     private handleMessage;
     private connect;
-    protected send<const T extends RpcMethod>(requests: JsonRpcRequest<T>[]): Promise<Response[]>;
+    protected send(requests: JsonRpcRequest<RpcMethod>[], requestMap: RequestMap): Promise<void>;
 }
 
 export { WsClient as default };

package/dist/WsClient.mjs

@@ -1,44 +1,47 @@
 // src/WsClient.ts
 import { deferredPromise, once, sleep } from "@chainflip/utils/async";
+import { z } from "zod";
 import Client from "./Client.mjs";
 import { rpcResponse } from "./common.mjs";
+var CONNECTING = "CONNECTING";
 var READY = "READY";
 var DISCONNECT = "DISCONNECT";
 var WsClient = class extends Client {
-  constructor(url, WebSocket = globalThis.WebSocket) {
-    super(url);
-    this.WebSocket = WebSocket;
-  }
   ws;
   reconnectAttempts = 0;
   emitter = new EventTarget();
-  requestMap = /* @__PURE__ */ new Map();
-  async close() {
-    await this.handleClose();
+  inFlightRequestMap = /* @__PURE__ */ new Map();
+  timeout;
+  shouldConnect = true;
+  constructor(url, { timeout = 3e4 } = {}) {
+    super(url);
+    this.timeout = timeout;
   }
-  async handleClose() {
+  async close() {
+    this.shouldConnect = false;
     if (!this.ws) return;
-    this.ws.removeEventListener("close", this.handleDisconnect);
+    await this.handleDisconnect();
+    const waitForClose = this.ws.readyState === WebSocket.OPEN;
     this.ws.close();
-    if (this.ws.readyState !== this.WebSocket.CLOSED) {
-      await once(this.ws, "close");
-    }
+    if (waitForClose) await once(this.ws, "close");
+    this.ws = void 0;
   }
   async connectionReady() {
     if (!this.ws) {
       return this.connect();
     }
-    if (this.ws.readyState !== this.WebSocket.OPEN) {
+    if (this.ws.readyState !== WebSocket.OPEN) {
       await once(this.emitter, READY, { timeout: 3e4 });
     }
     return this.ws;
   }
   handleDisconnect = async () => {
     this.emitter.dispatchEvent(new Event(DISCONNECT));
-    this.requestMap.forEach((request) => {
+    this.inFlightRequestMap.forEach((request) => {
       request.reject(new Error("disconnected"));
     });
-    this.requestMap.clear();
+    this.inFlightRequestMap.clear();
+    if (!this.shouldConnect) return;
     const backoff = 250 * 2 ** this.reconnectAttempts;
     await sleep(backoff);
     await this.connect().catch(() => {
@@ -47,65 +50,75 @@ var WsClient = class extends Client {
   };
   handleMessage = (data) => {
     const parsedData = JSON.parse(data.data);
-    const response = rpcResponse.safeParse(parsedData);
-    if (!response.success) return;
-    const { id } = response.data;
-    this.requestMap.get(id)?.resolve(response.data);
+    const responses = z.array(rpcResponse).safeParse(parsedData);
+    if (!responses.success) return;
+    for (const response of responses.data) {
+      const { id } = response;
+      this.inFlightRequestMap.get(id)?.resolve(response);
+    }
   };
   async connect() {
-    const socket = new this.WebSocket(this.url);
+    this.shouldConnect = true;
+    this.emitter.dispatchEvent(new Event(CONNECTING));
+    const socket = new WebSocket(this.url);
     this.ws = socket;
     this.ws.addEventListener("message", this.handleMessage);
+    let connected = false;
+    const handleConnectionError = () => {
+      if (!connected) {
+        void this.handleDisconnect();
+      }
+    };
     this.ws.addEventListener("close", this.handleDisconnect, { once: true });
-    await once(this.ws, "open", { timeout: 3e4 });
+    this.ws.addEventListener("error", handleConnectionError, { once: true });
+    await once(this.ws, "open", { timeout: this.timeout });
+    connected = true;
     this.ws.addEventListener("error", () => {
       socket.close();
     });
     this.emitter.dispatchEvent(new Event(READY));
+    this.ws.removeEventListener("error", handleConnectionError);
     this.reconnectAttempts = 0;
     return socket;
   }
-  async send(requests) {
-    const responses = [];
-    for (const data of requests) {
-      const MAX_RETRIES = 5;
-      for (let i = 0; i < MAX_RETRIES; i += 1) {
-        let socket;
-        try {
-          socket = await this.connectionReady();
-        } catch {
-          continue;
-        }
-        socket.send(JSON.stringify(data));
-        const request = deferredPromise();
-        this.requestMap.set(data.id, request);
-        const controller = new AbortController();
-        const result = await Promise.race([
-          sleep(3e4, { signal: controller.signal }).then(
-            () => ({ success: false, retry: false, error: new Error("timeout") })
+  async send(requests, requestMap) {
+    const MAX_RETRIES = 5;
+    let socket;
+    for (let i = 0; i < MAX_RETRIES; i += 1) {
+      try {
+        socket = await this.connectionReady();
+      } catch {
+        continue;
+      }
+    }
+    if (!socket) {
+      this.handleErrorResponse(new Error("failed to connect"), requestMap);
+      return;
+    }
+    socket.send(JSON.stringify(requests));
+    const promises = [];
+    for (const [id] of requestMap) {
+      const result = deferredPromise();
+      const controller = new AbortController();
+      this.inFlightRequestMap.set(id, result);
+      promises.push(
+        Promise.race([
+          sleep(this.timeout, { signal: controller.signal }).then(
+            () => ({ id, success: false, error: new Error("timeout") })
           ),
-          request.promise.then(
-            (r) => ({ success: true, result: r }),
-            (error) => ({ success: false, error, retry: true })
+          result.promise.then(
+            (r) => ({ id, success: true, result: r }),
+            (error) => ({ id, success: false, error })
           )
-        ]).finally(() => {
-          this.requestMap.delete(data.id);
+        ]).then((response) => {
+          this.handleResponse(response, requestMap);
+        }).finally(() => {
+          this.inFlightRequestMap.delete(id);
           controller.abort();
-        });
-        if (result.success || !result.retry) {
-          responses.push({ ...result, id: data.id });
-          break;
-        }
-        if (i === MAX_RETRIES - 1) {
-          responses.push({
-            success: false,
-            error: new Error("max retries exceeded"),
-            id: data.id
-          });
-        }
-      }
+        })
+      );
     }
-    return responses;
+    await Promise.all(promises);
   }
 };
 export {

package/dist/common.cjs

@@ -26,7 +26,7 @@
 var _parserscjs = require('./parsers.cjs');
 
 var rpcResult = {
-  broker_requestSwapDepositAddress: _parserscjs.brokerRequestSwapDepositAddress,
+  broker_request_swap_deposit_address: _parserscjs.brokerRequestSwapDepositAddress,
   broker_request_swap_parameter_encoding: _parserscjs.requestSwapParameterEncoding,
   cf_request_swap_parameter_encoding: _parserscjs.requestSwapParameterEncoding,
   cf_accounts: _parserscjs.cfAccounts,

package/dist/common.d.cts

@@ -65,18 +65,18 @@ type RequestSwapParameterEncodingParams = [
     dcaParams?: Nullish<DcaParams>
 ];
 type RpcRequest = WithHash<{
-    broker_requestSwapDepositAddress: [
+    broker_request_swap_deposit_address: [
         sourceAsset: UncheckedAssetAndChain,
         destinationAsset: UncheckedAssetAndChain,
         destinationAddress: string,
         brokerCommission: number,
-        ccmMetadata?: Nullish<CcmParams>,
-        boostFee?: Nullish<number>,
-        affiliateFees?: Nullish<{
+        ccmMetadata: Nullish<CcmParams>,
+        boostFee: Nullish<number>,
+        affiliateFees: Nullish<{
             account: string;
             bps: number;
         }[]>,
-        fillOrKillParams?: Nullish<FillOrKillParams>,
+        fillOrKillParams: FillOrKillParams,
         dcaParams?: Nullish<DcaParams>
     ];
     broker_request_swap_parameter_encoding: RequestSwapParameterEncodingParams;
@@ -154,7 +154,7 @@ type RpcRequest = WithHash<{
     chain_getBlockHash: [blockHeight?: number];
 };
 declare const rpcResult: {
-    readonly broker_requestSwapDepositAddress: z.ZodObject<{
+    readonly broker_request_swap_deposit_address: z.ZodObject<{
         address: z.ZodString;
         issued_block: z.ZodNumber;
         channel_id: z.ZodNumber;

package/dist/common.d.ts

@@ -65,18 +65,18 @@ type RequestSwapParameterEncodingParams = [
     dcaParams?: Nullish<DcaParams>
 ];
 type RpcRequest = WithHash<{
-    broker_requestSwapDepositAddress: [
+    broker_request_swap_deposit_address: [
         sourceAsset: UncheckedAssetAndChain,
         destinationAsset: UncheckedAssetAndChain,
         destinationAddress: string,
         brokerCommission: number,
-        ccmMetadata?: Nullish<CcmParams>,
-        boostFee?: Nullish<number>,
-        affiliateFees?: Nullish<{
+        ccmMetadata: Nullish<CcmParams>,
+        boostFee: Nullish<number>,
+        affiliateFees: Nullish<{
             account: string;
             bps: number;
         }[]>,
-        fillOrKillParams?: Nullish<FillOrKillParams>,
+        fillOrKillParams: FillOrKillParams,
         dcaParams?: Nullish<DcaParams>
     ];
     broker_request_swap_parameter_encoding: RequestSwapParameterEncodingParams;
@@ -154,7 +154,7 @@ type RpcRequest = WithHash<{
     chain_getBlockHash: [blockHeight?: number];
 };
 declare const rpcResult: {
-    readonly broker_requestSwapDepositAddress: z.ZodObject<{
+    readonly broker_request_swap_deposit_address: z.ZodObject<{
         address: z.ZodString;
         issued_block: z.ZodNumber;
         channel_id: z.ZodNumber;

package/dist/common.mjs

@@ -26,7 +26,7 @@ import {
 } from "./parsers.mjs";
 import { rpcResponse } from "./parsers.mjs";
 var rpcResult = {
-  broker_requestSwapDepositAddress: brokerRequestSwapDepositAddress,
+  broker_request_swap_deposit_address: brokerRequestSwapDepositAddress,
   broker_request_swap_parameter_encoding: requestSwapParameterEncoding,
   cf_request_swap_parameter_encoding: requestSwapParameterEncoding,
   cf_accounts: cfAccounts,

package/dist/index.d.cts

@@ -5,5 +5,6 @@ export { c as constants } from './constants-jLrn-AnI.cjs';
 export { RpcLimitOrder, RpcRangeOrder } from './parsers.cjs';
 export { RpcMethod, RpcRequest as RpcParams, RpcResult } from './common.cjs';
 import './Client.cjs';
+import '@chainflip/utils/async';
 import 'zod';
 import '@chainflip/utils/types';

package/dist/index.d.ts

@@ -5,5 +5,6 @@ export { c as constants } from './constants-jLrn-AnI.js';
 export { RpcLimitOrder, RpcRangeOrder } from './parsers.js';
 export { RpcMethod, RpcRequest as RpcParams, RpcResult } from './common.js';
 import './Client.js';
+import '@chainflip/utils/async';
 import 'zod';
 import '@chainflip/utils/types';

package/dist/parsers.cjs

@@ -45,7 +45,7 @@ var rename = (mapping) => (obj) => Object.fromEntries(
   ])
 );
 var rpcBaseResponse = _zod.z.object({
-  id: _zod.z.union([_zod.z.string(), _zod.z.number()]),
+  id: _zod.z.string(),
   jsonrpc: _zod.z.literal("2.0")
 });
 var nonNullish = _zod.z.any().refine(_guard.isNotNullish, { message: "Value must not be null or undefined" });

package/dist/parsers.d.cts

@@ -99,20 +99,20 @@ type Rename<T, U extends Record<string, string>> = Omit<T, keyof U> & {
     [K in keyof U as NonNullable<U[K]>]: K extends keyof T ? T[K] : never;
 };
 declare const rpcResponse: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
-    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    id: z.ZodString;
     jsonrpc: z.ZodLiteral<"2.0">;
 }, {
     result: z.ZodEffects<z.ZodAny, any, any>;
 }>, "strip", z.ZodTypeAny, {
-    id: string | number;
+    id: string;
     jsonrpc: "2.0";
     result?: any;
 }, {
-    id: string | number;
+    id: string;
     jsonrpc: "2.0";
     result?: any;
 }>, z.ZodObject<z.objectUtil.extendShape<{
-    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    id: z.ZodString;
     jsonrpc: z.ZodLiteral<"2.0">;
 }, {
     error: z.ZodObject<{
@@ -126,14 +126,14 @@ declare const rpcResponse: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
         message: string;
     }>;
 }>, "strip", z.ZodTypeAny, {
-    id: string | number;
+    id: string;
     jsonrpc: "2.0";
     error: {
         code: number;
         message: string;
     };
 }, {
-    id: string | number;
+    id: string;
     jsonrpc: "2.0";
     error: {
         code: number;

package/dist/parsers.d.ts

@@ -99,20 +99,20 @@ type Rename<T, U extends Record<string, string>> = Omit<T, keyof U> & {
     [K in keyof U as NonNullable<U[K]>]: K extends keyof T ? T[K] : never;
 };
 declare const rpcResponse: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
-    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    id: z.ZodString;
     jsonrpc: z.ZodLiteral<"2.0">;
 }, {
     result: z.ZodEffects<z.ZodAny, any, any>;
 }>, "strip", z.ZodTypeAny, {
-    id: string | number;
+    id: string;
     jsonrpc: "2.0";
     result?: any;
 }, {
-    id: string | number;
+    id: string;
     jsonrpc: "2.0";
     result?: any;
 }>, z.ZodObject<z.objectUtil.extendShape<{
-    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    id: z.ZodString;
     jsonrpc: z.ZodLiteral<"2.0">;
 }, {
     error: z.ZodObject<{
@@ -126,14 +126,14 @@ declare const rpcResponse: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
         message: string;
     }>;
 }>, "strip", z.ZodTypeAny, {
-    id: string | number;
+    id: string;
     jsonrpc: "2.0";
     error: {
         code: number;
         message: string;
     };
 }, {
-    id: string | number;
+    id: string;
     jsonrpc: "2.0";
     error: {
         code: number;

package/dist/parsers.mjs

@@ -45,7 +45,7 @@ var rename = (mapping) => (obj) => Object.fromEntries(
   ])
 );
 var rpcBaseResponse = z.object({
-  id: z.union([z.string(), z.number()]),
+  id: z.string(),
   jsonrpc: z.literal("2.0")
 });
 var nonNullish = z.any().refine(isNotNullish, { message: "Value must not be null or undefined" });

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@chainflip/rpc",
-  "version": "1.8.7",
+  "version": "1.8.8",
   "type": "module",
   "dependencies": {
-    "@chainflip/utils": "0.6.0",
+    "@chainflip/utils": "0.7.0",
     "zod": "^3.24.2"
   },
   "devDependencies": {
-    "@types/node": "^22.13.8",
-    "@types/ws": "^8.5.14",
+    "@types/node": "^22.13.10",
+    "@types/ws": "^8.18.0",
     "ws": "^8.18.1"
   },
   "files": [