@chainflip/rpc 1.9.0-assethub.1 → 1.9.1

package/dist/Client.cjs

@@ -1,45 +1,77 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/Client.ts
-var _crypto = require('crypto');
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;// src/Client.ts
+var _async = require('@chainflip/utils/async');
+
+
 var _commoncjs = require('./common.cjs');
-var Client = class {
-  constructor(url) {
+var Client = (_class = class {
+  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 _crypto.randomUUID.call(void 0, );
+    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;
+      return clonedItem.deferred.reject(response.error);
     }
-    const parseResult = _commoncjs.rpcResponse.safeParse(response.result);
-    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}`
+    const rpcResponse = response.result;
+    if ("error" in rpcResponse) {
+      return clonedItem.deferred.reject(
+        new Error(`RPC error [${rpcResponse.error.code}]: ${rpcResponse.error.message}`)
       );
     }
-    if (parseResult.data.result) {
-      return parseResult.data;
+    const parseResult = _commoncjs.rpcResult[clonedItem.method].safeParse(rpcResponse.result);
+    if (parseResult.error) {
+      return clonedItem.deferred.reject(parseResult.error);
     }
-    throw new Error("Malformed RPC response received");
+    clonedItem.deferred.resolve(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);
+  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();
   }
-};
+}, _class);
 
 
 exports.default = Client;

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,25 +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}-${string}-${string}-${string}-${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,25 +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}-${string}-${string}-${string}-${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,40 +1,72 @@
 // src/Client.ts
-import { randomUUID } from "crypto";
-import { rpcResult, rpcResponse } from "./common.mjs";
+import { deferredPromise } from "@chainflip/utils/async";
+import {
+  rpcResult
+} from "./common.mjs";
 var Client = class {
   constructor(url) {
     this.url = url;
   }
+  lastRequestId = 0;
+  timer = null;
+  requestMap = /* @__PURE__ */ new Map();
   getRequestId() {
-    return randomUUID();
+    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}`)
       );
     }
-    if (parseResult.data.result) {
-      return parseResult.data;
+    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);
     }
-    throw new Error("Malformed RPC response received");
-  }
-  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);
+    return deferred.promise;
   }
   methods() {
     return Object.keys(rpcResult).sort();

package/dist/HttpClient.cjs

@@ -1,76 +1,34 @@
-"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);_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),
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
+var HttpClient = class extends _Clientcjs2.default {
+  async send(request, requestMap) {
+    let res;
+    try {
+      res = await fetch(this.url, {
+        body: JSON.stringify(request),
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (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)
-      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);
+      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,16 +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 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;
+    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>[], requestMap: RequestMap): Promise<void>;
 }
 
 export { HttpClient as default };

package/dist/HttpClient.d.ts

@@ -1,16 +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 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;
+    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>[], requestMap: RequestMap): Promise<void>;
 }
 
 export { HttpClient as default };

package/dist/HttpClient.mjs

@@ -1,74 +1,32 @@
 // 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),
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
+  async send(request, requestMap) {
+    let res;
+    try {
+      res = await fetch(this.url, {
+        body: JSON.stringify(request),
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (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)
-      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);
+      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 {