@chainflip/rpc 1.6.8 → 1.6.10

package/dist/Client.cjs

@@ -1,33 +1,43 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/Client.ts
-var _commoncjs = require('./common.cjs');
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;// src/Client.ts
 var _assertion = require('@chainflip/utils/assertion');
-var Client = class {
-  constructor(url) {
+var _commoncjs = require('./common.cjs');
+var Client = (_class = class {
+  constructor(url) {;_class.prototype.__init.call(this);
     this.url = url;
   }
+  __init() {this.lastRequestId = 0}
   getRequestId() {
-    return "1";
+    return String(++this.lastRequestId);
   }
   formatRequest(method, params) {
     return { jsonrpc: "2.0", id: this.getRequestId(), method, params };
   }
-  async sendRequest(method, ...params) {
-    const response = await this.send(this.formatRequest(method, params));
-    if (!response.success)
+  parseSingleResponse(response) {
+    if (!response.success) {
       throw response.error;
+    }
     const parseResult = _commoncjs.rpcResponse.safeParse(response.result);
-    _assertion.assert.call(void 0, parseResult.success, "Malformed RPC response received");
+    if (!parseResult.success) {
+      throw new Error("Malformed RPC response received");
+    }
     if ("error" in parseResult.data) {
       throw new Error(
         `RPC error [${parseResult.data.error.code}]: ${parseResult.data.error.message}`
       );
     }
-    return _commoncjs.rpcResult[method].parse(parseResult.data.result);
+    _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);
   }
   methods() {
     return Object.keys(_commoncjs.rpcResult).sort();
   }
-};
+}, _class);
 
 
 exports.default = Client;

package/dist/Client.d.cts

@@ -3,20 +3,29 @@ import '@chainflip/utils/types';
 import 'zod';
 import './parsers.cjs';
 
+type Response = {
+    success: true;
+    id: string;
+    result: unknown;
+} | {
+    success: false;
+    id: string;
+    error: Error;
+};
 declare abstract class Client {
     protected readonly url: string;
+    private lastRequestId;
     constructor(url: string);
-    protected abstract send<const T extends RpcMethod>(data: JsonRpcRequest<T>): Promise<{
-        success: true;
-        result: unknown;
-    } | {
-        success: false;
-        error: Error;
-    }>;
+    protected abstract send<const T extends RpcMethod>(data: JsonRpcRequest<T>[]): Promise<Response[]>;
     protected getRequestId(): string;
-    private formatRequest;
+    protected formatRequest<T extends RpcMethod>(method: T, params: RpcRequest[T]): JsonRpcRequest<T>;
+    protected parseSingleResponse(response: Response): {
+        id: string | number;
+        jsonrpc: "2.0";
+        result?: any;
+    };
     sendRequest<const T extends RpcMethod>(method: T, ...params: RpcRequest[T]): Promise<RpcResult<T>>;
     methods(): RpcMethod[];
 }
 
-export { Client as default };
+export { type Response, Client as default };

package/dist/Client.d.ts

@@ -3,20 +3,29 @@ import '@chainflip/utils/types';
 import 'zod';
 import './parsers.js';
 
+type Response = {
+    success: true;
+    id: string;
+    result: unknown;
+} | {
+    success: false;
+    id: string;
+    error: Error;
+};
 declare abstract class Client {
     protected readonly url: string;
+    private lastRequestId;
     constructor(url: string);
-    protected abstract send<const T extends RpcMethod>(data: JsonRpcRequest<T>): Promise<{
-        success: true;
-        result: unknown;
-    } | {
-        success: false;
-        error: Error;
-    }>;
+    protected abstract send<const T extends RpcMethod>(data: JsonRpcRequest<T>[]): Promise<Response[]>;
     protected getRequestId(): string;
-    private formatRequest;
+    protected formatRequest<T extends RpcMethod>(method: T, params: RpcRequest[T]): JsonRpcRequest<T>;
+    protected parseSingleResponse(response: Response): {
+        id: string | number;
+        jsonrpc: "2.0";
+        result?: any;
+    };
     sendRequest<const T extends RpcMethod>(method: T, ...params: RpcRequest[T]): Promise<RpcResult<T>>;
     methods(): RpcMethod[];
 }
 
-export { Client as default };
+export { type Response, Client as default };

package/dist/Client.mjs

@@ -1,28 +1,38 @@
 // src/Client.ts
-import { rpcResult, rpcResponse } from "./common.mjs";
 import { assert } from "@chainflip/utils/assertion";
+import { rpcResult, rpcResponse } from "./common.mjs";
 var Client = class {
   constructor(url) {
     this.url = url;
   }
+  lastRequestId = 0;
   getRequestId() {
-    return "1";
+    return String(++this.lastRequestId);
   }
   formatRequest(method, params) {
     return { jsonrpc: "2.0", id: this.getRequestId(), method, params };
   }
-  async sendRequest(method, ...params) {
-    const response = await this.send(this.formatRequest(method, params));
-    if (!response.success)
+  parseSingleResponse(response) {
+    if (!response.success) {
       throw response.error;
+    }
     const parseResult = rpcResponse.safeParse(response.result);
-    assert(parseResult.success, "Malformed RPC response received");
+    if (!parseResult.success) {
+      throw new Error("Malformed RPC response received");
+    }
     if ("error" in parseResult.data) {
       throw new Error(
         `RPC error [${parseResult.data.error.code}]: ${parseResult.data.error.message}`
       );
     }
-    return rpcResult[method].parse(parseResult.data.result);
+    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);
   }
   methods() {
     return Object.keys(rpcResult).sort();

package/dist/HttpClient.cjs

@@ -1,6 +1,13 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/HttpClient.ts
+"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');
 var _Clientcjs = require('./Client.cjs'); var _Clientcjs2 = _interopRequireDefault(_Clientcjs);
-var HttpClient = class extends _Clientcjs2.default {
+
+
+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);_class.prototype.__init3.call(this); }
+  __init() {this.timer = null}
+  __init2() {this.batchDuration = 100}
+  __init3() {this.requestMap = /* @__PURE__ */ new Map()}
   async send(request) {
     const res = await fetch(this.url, {
       body: JSON.stringify(request),
@@ -10,16 +17,59 @@ var HttpClient = class extends _Clientcjs2.default {
       }
     });
     if (!res.ok) {
-      return { success: false, error: new Error(`HTTP error: ${res.status}`) };
+      return request.map((r) => ({
+        id: r.id,
+        success: false,
+        error: new Error(`HTTP error: ${res.status}`)
+      }));
     }
     try {
-      const result = await res.json();
-      return { success: true, result };
+      const jsonRpcResponse = await res.json();
+      return jsonRpcResponse.map((r) => ({ id: r.id, success: true, result: r }));
     } catch (cause) {
-      return { success: false, error: new Error("Invalid JSON response", { 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) clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.sendBatch(), this.batchDuration);
+    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);
+      }
+    }
+    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,17 +1,16 @@
-import Client from './Client.cjs';
-import { RpcMethod, JsonRpcRequest } from './common.cjs';
+import Client, { Response } from './Client.cjs';
+import { RpcMethod, JsonRpcRequest, RpcRequest, RpcResult } from './common.cjs';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.cjs';
 
 declare class HttpClient extends Client {
-    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>): Promise<{
-        success: true;
-        result: unknown;
-    } | {
-        success: false;
-        error: Error;
-    }>;
+    private timer;
+    private batchDuration;
+    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;
 }
 
 export { HttpClient as default };

package/dist/HttpClient.d.ts

@@ -1,17 +1,16 @@
-import Client from './Client.js';
-import { RpcMethod, JsonRpcRequest } from './common.js';
+import Client, { Response } from './Client.js';
+import { RpcMethod, JsonRpcRequest, RpcRequest, RpcResult } from './common.js';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.js';
 
 declare class HttpClient extends Client {
-    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>): Promise<{
-        success: true;
-        result: unknown;
-    } | {
-        success: false;
-        error: Error;
-    }>;
+    private timer;
+    private batchDuration;
+    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;
 }
 
 export { HttpClient as default };

package/dist/HttpClient.mjs

@@ -1,6 +1,13 @@
 // 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;
+  batchDuration = 100;
+  requestMap = /* @__PURE__ */ new Map();
   async send(request) {
     const res = await fetch(this.url, {
       body: JSON.stringify(request),
@@ -10,15 +17,58 @@ var HttpClient = class extends Client {
       }
     });
     if (!res.ok) {
-      return { success: false, error: new Error(`HTTP error: ${res.status}`) };
+      return request.map((r) => ({
+        id: r.id,
+        success: false,
+        error: new Error(`HTTP error: ${res.status}`)
+      }));
     }
     try {
-      const result = await res.json();
-      return { success: true, result };
+      const jsonRpcResponse = await res.json();
+      return jsonRpcResponse.map((r) => ({ id: r.id, success: true, result: r }));
     } catch (cause) {
-      return { success: false, error: new Error("Invalid JSON response", { 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) clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.sendBatch(), this.batchDuration);
+    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);
+      }
+    }
+    clonedMap.forEach((item) => {
+      item.deferred.reject(new Error("Could not find the result for the request"));
+    });
+  }
 };
 export {
   HttpClient as default

package/dist/WsClient.cjs

@@ -1,6 +1,5 @@
 "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 _crypto = require('crypto');
 var _Clientcjs = require('./Client.cjs'); var _Clientcjs2 = _interopRequireDefault(_Clientcjs);
 var _commoncjs = require('./common.cjs');
 var READY = "READY";
@@ -14,15 +13,11 @@ var WsClient = (_class = class extends _Clientcjs2.default {
   __init() {this.reconnectAttempts = 0}
   __init2() {this.emitter = new EventTarget()}
   __init3() {this.requestMap = /* @__PURE__ */ new Map()}
-  getRequestId() {
-    return _crypto.randomUUID.call(void 0, );
-  }
   async close() {
     await this.handleClose();
   }
   async handleClose() {
-    if (!this.ws)
-      return;
+    if (!this.ws) return;
     this.ws.removeEventListener("close", this.handleDisconnect);
     this.ws.close();
     if (this.ws.readyState !== this.WebSocket.CLOSED) {
@@ -53,8 +48,7 @@ var WsClient = (_class = class extends _Clientcjs2.default {
   __init5() {this.handleMessage = (data) => {
     const parsedData = JSON.parse(data.data);
     const response = _commoncjs.rpcResponse.safeParse(parsedData);
-    if (!response.success)
-      return;
+    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)]);
   }}
@@ -71,36 +65,47 @@ var WsClient = (_class = class extends _Clientcjs2.default {
     this.reconnectAttempts = 0;
     return socket;
   }
-  async send(data) {
-    let requestId = data.id;
-    for (let i = 0; i < 5; i += 1) {
-      let socket;
-      try {
-        socket = await this.connectionReady();
-      } catch (e) {
-        continue;
+  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") })
+          ),
+          request.promise.then(
+            (result2) => ({ success: true, result: result2 }),
+            (error) => ({ success: false, error, retry: true })
+          )
+        ]).finally(() => {
+          this.requestMap.delete(data.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
+          });
+        }
       }
-      socket.send(JSON.stringify({ ...data, id: requestId }));
-      const request = _async.deferredPromise.call(void 0, );
-      this.requestMap.set(requestId, 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") })
-        ),
-        request.promise.then(
-          (result2) => ({ success: true, result: result2 }),
-          (error) => ({ success: false, error, retry: true })
-        )
-      ]).finally(() => {
-        this.requestMap.delete(requestId);
-        controller.abort();
-      });
-      if (result.success || !result.retry)
-        return result;
-      requestId = this.getRequestId();
     }
-    return { success: false, error: new Error("max retries exceeded") };
+    return responses;
   }
 }, _class);
 

package/dist/WsClient.d.cts

@@ -1,4 +1,4 @@
-import Client from './Client.cjs';
+import Client, { Response } from './Client.cjs';
 import { RpcMethod, JsonRpcRequest } from './common.cjs';
 import '@chainflip/utils/types';
 import 'zod';
@@ -11,20 +11,13 @@ declare class WsClient extends Client {
     private emitter;
     private requestMap;
     constructor(url: string, WebSocket?: typeof globalThis.WebSocket);
-    protected getRequestId(): `${string}-${string}-${string}-${string}-${string}`;
     close(): Promise<void>;
     private handleClose;
     private connectionReady;
     private handleDisconnect;
     private handleMessage;
     private connect;
-    protected send<const T extends RpcMethod>(data: JsonRpcRequest<T>): Promise<{
-        success: true;
-        result: unknown;
-    } | {
-        success: false;
-        error: Error;
-    }>;
+    protected send<const T extends RpcMethod>(requests: JsonRpcRequest<T>[]): Promise<Response[]>;
 }
 
 export { WsClient as default };

package/dist/WsClient.d.ts

@@ -1,4 +1,4 @@
-import Client from './Client.js';
+import Client, { Response } from './Client.js';
 import { RpcMethod, JsonRpcRequest } from './common.js';
 import '@chainflip/utils/types';
 import 'zod';
@@ -11,20 +11,13 @@ declare class WsClient extends Client {
     private emitter;
     private requestMap;
     constructor(url: string, WebSocket?: typeof globalThis.WebSocket);
-    protected getRequestId(): `${string}-${string}-${string}-${string}-${string}`;
     close(): Promise<void>;
     private handleClose;
     private connectionReady;
     private handleDisconnect;
     private handleMessage;
     private connect;
-    protected send<const T extends RpcMethod>(data: JsonRpcRequest<T>): Promise<{
-        success: true;
-        result: unknown;
-    } | {
-        success: false;
-        error: Error;
-    }>;
+    protected send<const T extends RpcMethod>(requests: JsonRpcRequest<T>[]): Promise<Response[]>;
 }
 
 export { WsClient as default };

package/dist/WsClient.mjs

@@ -1,6 +1,5 @@
 // src/WsClient.ts
 import { deferredPromise, once, sleep } from "@chainflip/utils/async";
-import { randomUUID } from "crypto";
 import Client from "./Client.mjs";
 import { rpcResponse } from "./common.mjs";
 var READY = "READY";
@@ -14,15 +13,11 @@ var WsClient = class extends Client {
   reconnectAttempts = 0;
   emitter = new EventTarget();
   requestMap = /* @__PURE__ */ new Map();
-  getRequestId() {
-    return randomUUID();
-  }
   async close() {
     await this.handleClose();
   }
   async handleClose() {
-    if (!this.ws)
-      return;
+    if (!this.ws) return;
     this.ws.removeEventListener("close", this.handleDisconnect);
     this.ws.close();
     if (this.ws.readyState !== this.WebSocket.CLOSED) {
@@ -53,8 +48,7 @@ var WsClient = class extends Client {
   handleMessage = (data) => {
     const parsedData = JSON.parse(data.data);
     const response = rpcResponse.safeParse(parsedData);
-    if (!response.success)
-      return;
+    if (!response.success) return;
     const { id } = response.data;
     this.requestMap.get(id)?.resolve(response.data);
   };
@@ -71,36 +65,47 @@ var WsClient = class extends Client {
     this.reconnectAttempts = 0;
     return socket;
   }
-  async send(data) {
-    let requestId = data.id;
-    for (let i = 0; i < 5; i += 1) {
-      let socket;
-      try {
-        socket = await this.connectionReady();
-      } catch {
-        continue;
+  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") })
+          ),
+          request.promise.then(
+            (result2) => ({ success: true, result: result2 }),
+            (error) => ({ success: false, error, retry: true })
+          )
+        ]).finally(() => {
+          this.requestMap.delete(data.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
+          });
+        }
       }
-      socket.send(JSON.stringify({ ...data, id: requestId }));
-      const request = deferredPromise();
-      this.requestMap.set(requestId, request);
-      const controller = new AbortController();
-      const result = await Promise.race([
-        sleep(3e4, { signal: controller.signal }).then(
-          () => ({ success: false, retry: false, error: new Error("timeout") })
-        ),
-        request.promise.then(
-          (result2) => ({ success: true, result: result2 }),
-          (error) => ({ success: false, error, retry: true })
-        )
-      ]).finally(() => {
-        this.requestMap.delete(requestId);
-        controller.abort();
-      });
-      if (result.success || !result.retry)
-        return result;
-      requestId = this.getRequestId();
     }
-    return { success: false, error: new Error("max retries exceeded") };
+    return responses;
   }
 };
 export {