@chainflip/rpc 1.8.9 → 1.9.0-assethub.1

package/dist/Client.cjs

@@ -1,77 +1,45 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;// src/Client.ts
-var _async = require('@chainflip/utils/async');
-
-
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/Client.ts
+var _crypto = require('crypto');
 var _commoncjs = require('./common.cjs');
-var Client = (_class = class {
-  constructor(url) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+var Client = class {
+  constructor(url) {
     this.url = url;
   }
-  __init() {this.lastRequestId = 0}
-  __init2() {this.timer = null}
-  __init3() {this.requestMap = /* @__PURE__ */ new Map()}
   getRequestId() {
-    try {
-      return crypto.randomUUID();
-    } catch (e) {
-      return String(++this.lastRequestId);
-    }
+    return _crypto.randomUUID.call(void 0, );
   }
   formatRequest(method, params) {
     return { jsonrpc: "2.0", id: this.getRequestId(), method, params };
   }
-  handleResponse(response, clonedMap) {
-    const clonedItem = clonedMap.get(response.id);
-    if (!clonedItem) return;
-    clonedMap.delete(response.id);
+  parseSingleResponse(response) {
     if (!response.success) {
-      return clonedItem.deferred.reject(response.error);
+      throw response.error;
     }
-    const rpcResponse = response.result;
-    if ("error" in rpcResponse) {
-      return clonedItem.deferred.reject(
-        new Error(`RPC error [${rpcResponse.error.code}]: ${rpcResponse.error.message}`)
+    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 parseResult = _commoncjs.rpcResult[clonedItem.method].safeParse(rpcResponse.result);
-    if (parseResult.error) {
-      return clonedItem.deferred.reject(parseResult.error);
+    if (parseResult.data.result) {
+      return parseResult.data;
     }
-    clonedItem.deferred.resolve(parseResult.data);
+    throw new Error("Malformed RPC response received");
   }
-  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;
+  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

@@ -1,5 +1,4 @@
-import { DeferredPromise } from '@chainflip/utils/async';
-import { RpcMethod, JsonRpcRequest, RpcResult, JsonRpcResponse, RpcRequest } from './common.cjs';
+import { RpcMethod, JsonRpcRequest, RpcRequest, RpcResult } from './common.cjs';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.cjs';
@@ -7,31 +6,25 @@ import './parsers.cjs';
 type Response = {
     success: true;
     id: string;
-    result: JsonRpcResponse;
+    result: unknown;
 } | {
     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>[], clonedMap: RequestMap): Promise<void>;
-    private getRequestId;
-    private formatRequest;
-    protected handleResponse(response: Response, clonedMap: RequestMap): void;
-    protected handleErrorResponse(error: Error, clonedMap: RequestMap): void;
-    private handleBatch;
+    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;
+    };
     sendRequest<const T extends RpcMethod>(method: T, ...params: RpcRequest[T]): Promise<RpcResult<T>>;
     methods(): RpcMethod[];
 }
 
-export { type RequestMap, type Response, Client as default };
+export { type Response, Client as default };

package/dist/Client.d.ts

@@ -1,5 +1,4 @@
-import { DeferredPromise } from '@chainflip/utils/async';
-import { RpcMethod, JsonRpcRequest, RpcResult, JsonRpcResponse, RpcRequest } from './common.js';
+import { RpcMethod, JsonRpcRequest, RpcRequest, RpcResult } from './common.js';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.js';
@@ -7,31 +6,25 @@ import './parsers.js';
 type Response = {
     success: true;
     id: string;
-    result: JsonRpcResponse;
+    result: unknown;
 } | {
     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>[], clonedMap: RequestMap): Promise<void>;
-    private getRequestId;
-    private formatRequest;
-    protected handleResponse(response: Response, clonedMap: RequestMap): void;
-    protected handleErrorResponse(error: Error, clonedMap: RequestMap): void;
-    private handleBatch;
+    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;
+    };
     sendRequest<const T extends RpcMethod>(method: T, ...params: RpcRequest[T]): Promise<RpcResult<T>>;
     methods(): RpcMethod[];
 }
 
-export { type RequestMap, type Response, Client as default };
+export { type Response, Client as default };

package/dist/Client.mjs

@@ -1,72 +1,40 @@
 // src/Client.ts
-import { deferredPromise } from "@chainflip/utils/async";
-import {
-  rpcResult
-} from "./common.mjs";
+import { randomUUID } from "crypto";
+import { rpcResult, rpcResponse } from "./common.mjs";
 var Client = class {
   constructor(url) {
     this.url = url;
   }
-  lastRequestId = 0;
-  timer = null;
-  requestMap = /* @__PURE__ */ new Map();
   getRequestId() {
-    try {
-      return crypto.randomUUID();
-    } catch {
-      return String(++this.lastRequestId);
-    }
+    return randomUUID();
   }
   formatRequest(method, params) {
     return { jsonrpc: "2.0", id: this.getRequestId(), method, params };
   }
-  handleResponse(response, clonedMap) {
-    const clonedItem = clonedMap.get(response.id);
-    if (!clonedItem) return;
-    clonedMap.delete(response.id);
+  parseSingleResponse(response) {
     if (!response.success) {
-      return clonedItem.deferred.reject(response.error);
-    }
-    const rpcResponse = response.result;
-    if ("error" in rpcResponse) {
-      return clonedItem.deferred.reject(
-        new Error(`RPC error [${rpcResponse.error.code}]: ${rpcResponse.error.message}`)
-      );
-    }
-    const parseResult = rpcResult[clonedItem.method].safeParse(rpcResponse.result);
-    if (parseResult.error) {
-      return clonedItem.deferred.reject(parseResult.error);
+      throw response.error;
     }
-    clonedItem.deferred.resolve(parseResult.data);
-  }
-  handleErrorResponse(error, clonedMap) {
-    for (const [id] of clonedMap) {
-      this.handleResponse({ id, success: false, error }, clonedMap);
+    const parseResult = rpcResponse.safeParse(response.result);
+    if (!parseResult.success) {
+      throw new Error("Malformed RPC response received");
     }
-  }
-  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}`));
+    if ("error" in parseResult.data) {
+      throw new Error(
+        `RPC error [${parseResult.data.error.code}]: ${parseResult.data.error.message}`
+      );
     }
-    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);
+    if (parseResult.data.result) {
+      return parseResult.data;
     }
-    return deferred.promise;
+    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);
   }
   methods() {
     return Object.keys(rpcResult).sort();

package/dist/HttpClient.cjs

@@ -1,34 +1,76 @@
-"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 {
-  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;
-    }
+
+
+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"
+      }
+    });
     if (!res.ok) {
-      this.handleErrorResponse(new Error(`HTTP error: ${res.status}`), requestMap);
-      return;
+      return request.map((r) => ({
+        id: r.id,
+        success: false,
+        error: new Error(`HTTP error: ${res.status}`)
+      }));
     }
     try {
       const jsonRpcResponse = await res.json();
-      for (const r of jsonRpcResponse) {
-        this.handleResponse({ id: r.id, success: true, result: r }, requestMap);
-      }
+      return jsonRpcResponse.map((r) => ({ id: r.id, success: true, result: r }));
     } catch (cause) {
-      this.handleErrorResponse(new Error("Invalid JSON response", { cause }), requestMap);
+      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,12 +1,16 @@
-import Client, { RequestMap } from './Client.cjs';
-import { RpcMethod, JsonRpcRequest } from './common.cjs';
-import '@chainflip/utils/async';
+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>[], requestMap: RequestMap): Promise<void>;
+    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,12 +1,16 @@
-import Client, { RequestMap } from './Client.js';
-import { RpcMethod, JsonRpcRequest } from './common.js';
-import '@chainflip/utils/async';
+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>[], requestMap: RequestMap): Promise<void>;
+    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,32 +1,74 @@
 // src/HttpClient.ts
+import { deferredPromise } from "@chainflip/utils/async";
 import Client from "./Client.mjs";
+import {
+  rpcResult
+} from "./common.mjs";
 var HttpClient = class extends Client {
-  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;
-    }
+  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"
+      }
+    });
     if (!res.ok) {
-      this.handleErrorResponse(new Error(`HTTP error: ${res.status}`), requestMap);
-      return;
+      return request.map((r) => ({
+        id: r.id,
+        success: false,
+        error: new Error(`HTTP error: ${res.status}`)
+      }));
     }
     try {
       const jsonRpcResponse = await res.json();
-      for (const r of jsonRpcResponse) {
-        this.handleResponse({ id: r.id, success: true, result: r }, requestMap);
-      }
+      return jsonRpcResponse.map((r) => ({ id: r.id, success: true, result: r }));
     } catch (cause) {
-      this.handleErrorResponse(new Error("Invalid JSON response", { cause }), requestMap);
+      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 {