@chainflip/rpc 2.0.7 → 2.1.0-beta.1

package/dist/Client.cjs

@@ -1,93 +1,90 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;// src/Client.ts
-var _async = require('@chainflip/utils/async');
+const require_common = require('./common.cjs');
+let _chainflip_utils_async = require("@chainflip/utils/async");
 
+//#region src/Client.ts
+var Client = class {
+	lastRequestId = 0;
+	timer = null;
+	requestMap = /* @__PURE__ */ new Map();
+	archiveNodeUrl;
+	eventTarget = new EventTarget();
+	constructor(url, opts = {}) {
+		this.url = url;
+		this.archiveNodeUrl = opts.archiveNodeUrl;
+	}
+	getRequestId() {
+		try {
+			return crypto.randomUUID();
+		} catch {
+			return String(++this.lastRequestId);
+		}
+	}
+	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);
+		if (!response.success) return clonedItem.deferred.reject(response.error);
+		const rpcResponse = response.result;
+		if ("error" in rpcResponse) return clonedItem.deferred.reject(/* @__PURE__ */ new Error(`RPC error [${rpcResponse.error.code}]: ${rpcResponse.error.message}`));
+		const parseResult = require_common.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(/* @__PURE__ */ new Error("Could not find the result for the request"));
+		});
+	}
+	sendRequest(method, ...params) {
+		if (!require_common.rpcResult[method]) return Promise.reject(/* @__PURE__ */ new Error(`Unknown method: ${method}`));
+		const deferred = (0, _chainflip_utils_async.deferredPromise)();
+		const body = this.formatRequest(method, params);
+		this.requestMap.set(body.id, {
+			deferred,
+			body,
+			method
+		});
+		if (!this.timer) this.timer = setTimeout(() => {
+			this.timer = null;
+			this.handleBatch();
+		}, 0);
+		return deferred.promise.catch((error) => {
+			if (error instanceof Error) {
+				if (this.archiveNodeUrl && error.message.includes("Unknown block: State already discarded")) {
+					this.eventTarget.dispatchEvent(new CustomEvent("archiveNodeFallback", { detail: {
+						method,
+						params
+					} }));
+					return new this.constructor(this.archiveNodeUrl).sendRequest(method, ...params);
+				}
+				Error.captureStackTrace(error);
+			}
+			throw error;
+		});
+	}
+	methods() {
+		return Object.keys(require_common.rpcResult).sort();
+	}
+};
 
-var _commoncjs = require('./common.cjs');
-var Client = (_class = class {
-  constructor(url, opts = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
-    this.url = url;
-    this.archiveNodeUrl = opts.archiveNodeUrl;
-  }
-  __init() {this.lastRequestId = 0}
-  __init2() {this.timer = null}
-  __init3() {this.requestMap = /* @__PURE__ */ new Map()}
-  
-  __init4() {this.eventTarget = new EventTarget()}
-  getRequestId() {
-    try {
-      return crypto.randomUUID();
-    } catch (e) {
-      return String(++this.lastRequestId);
-    }
-  }
-  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);
-    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 = _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.catch((error) => {
-      if (error instanceof Error) {
-        if (this.archiveNodeUrl && error.message.includes("Unknown block: State already discarded")) {
-          this.eventTarget.dispatchEvent(
-            new CustomEvent("archiveNodeFallback", { detail: { method, params } })
-          );
-          return new this.constructor(
-            this.archiveNodeUrl
-          ).sendRequest(method, ...params);
-        }
-        Error.captureStackTrace(error);
-      }
-      throw error;
-    });
-  }
-  methods() {
-    return Object.keys(_commoncjs.rpcResult).sort();
-  }
-}, _class);
-
-
-exports.default = Client;
+//#endregion
+module.exports = Client;

package/dist/Client.d.cts

@@ -1,43 +1,40 @@
-import { DeferredPromise } from '@chainflip/utils/async';
-import { RpcMethod, JsonRpcRequest, RpcResult, JsonRpcResponse, RpcRequest } from './common.cjs';
-import '@chainflip/utils/chainflip';
-import '@chainflip/utils/types';
-import 'zod';
-import './parsers.cjs';
+import { JsonRpcRequest, JsonRpcResponse, RpcMethod, RpcRequest, RpcResult } from "./common.cjs";
+import { DeferredPromise } from "@chainflip/utils/async";
 
+//#region src/Client.d.ts
 type Response = {
-    success: true;
-    id: string;
-    result: JsonRpcResponse;
+  success: true;
+  id: string;
+  result: JsonRpcResponse;
 } | {
-    success: false;
-    id: string;
-    error: Error;
+  success: false;
+  id: string;
+  error: Error;
 };
 type RequestMap = Map<string, {
-    deferred: DeferredPromise<RpcResult<RpcMethod>>;
-    body: JsonRpcRequest<RpcMethod>;
-    method: RpcMethod;
+  deferred: DeferredPromise<RpcResult<RpcMethod>>;
+  body: JsonRpcRequest<RpcMethod>;
+  method: RpcMethod;
 }>;
 type ClientOpts = {
-    archiveNodeUrl?: string;
+  archiveNodeUrl?: string;
 };
 declare abstract class Client {
-    protected readonly url: string;
-    private lastRequestId;
-    private timer;
-    private requestMap;
-    private readonly archiveNodeUrl?;
-    readonly eventTarget: EventTarget;
-    constructor(url: string, opts?: ClientOpts);
-    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[];
+  protected readonly url: string;
+  private lastRequestId;
+  private timer;
+  private requestMap;
+  private readonly archiveNodeUrl?;
+  readonly eventTarget: EventTarget;
+  constructor(url: string, opts?: ClientOpts);
+  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 ClientOpts, type RequestMap, type Response, Client as default };
+//#endregion
+export { ClientOpts, RequestMap, Response, Client as default };

package/dist/Client.d.mts

@@ -0,0 +1,40 @@
+import { JsonRpcRequest, JsonRpcResponse, RpcMethod, RpcRequest, RpcResult } from "./common.mjs";
+import { DeferredPromise } from "@chainflip/utils/async";
+
+//#region src/Client.d.ts
+type Response = {
+  success: true;
+  id: string;
+  result: JsonRpcResponse;
+} | {
+  success: false;
+  id: string;
+  error: Error;
+};
+type RequestMap = Map<string, {
+  deferred: DeferredPromise<RpcResult<RpcMethod>>;
+  body: JsonRpcRequest<RpcMethod>;
+  method: RpcMethod;
+}>;
+type ClientOpts = {
+  archiveNodeUrl?: string;
+};
+declare abstract class Client {
+  protected readonly url: string;
+  private lastRequestId;
+  private timer;
+  private requestMap;
+  private readonly archiveNodeUrl?;
+  readonly eventTarget: EventTarget;
+  constructor(url: string, opts?: ClientOpts);
+  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[];
+}
+//#endregion
+export { ClientOpts, RequestMap, Response, Client as default };

package/dist/Client.mjs

@@ -1,93 +1,90 @@
-// src/Client.ts
+import { rpcResult } from "./common.mjs";
 import { deferredPromise } from "@chainflip/utils/async";
-import {
-  rpcResult
-} from "./common.mjs";
+
+//#region src/Client.ts
 var Client = class {
-  constructor(url, opts = {}) {
-    this.url = url;
-    this.archiveNodeUrl = opts.archiveNodeUrl;
-  }
-  lastRequestId = 0;
-  timer = null;
-  requestMap = /* @__PURE__ */ new Map();
-  archiveNodeUrl;
-  eventTarget = new EventTarget();
-  getRequestId() {
-    try {
-      return crypto.randomUUID();
-    } catch {
-      return String(++this.lastRequestId);
-    }
-  }
-  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);
-    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);
-    }
-    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.catch((error) => {
-      if (error instanceof Error) {
-        if (this.archiveNodeUrl && error.message.includes("Unknown block: State already discarded")) {
-          this.eventTarget.dispatchEvent(
-            new CustomEvent("archiveNodeFallback", { detail: { method, params } })
-          );
-          return new this.constructor(
-            this.archiveNodeUrl
-          ).sendRequest(method, ...params);
-        }
-        Error.captureStackTrace(error);
-      }
-      throw error;
-    });
-  }
-  methods() {
-    return Object.keys(rpcResult).sort();
-  }
-};
-export {
-  Client as default
+	lastRequestId = 0;
+	timer = null;
+	requestMap = /* @__PURE__ */ new Map();
+	archiveNodeUrl;
+	eventTarget = new EventTarget();
+	constructor(url, opts = {}) {
+		this.url = url;
+		this.archiveNodeUrl = opts.archiveNodeUrl;
+	}
+	getRequestId() {
+		try {
+			return crypto.randomUUID();
+		} catch {
+			return String(++this.lastRequestId);
+		}
+	}
+	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);
+		if (!response.success) return clonedItem.deferred.reject(response.error);
+		const rpcResponse = response.result;
+		if ("error" in rpcResponse) return clonedItem.deferred.reject(/* @__PURE__ */ 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);
+		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(/* @__PURE__ */ new Error("Could not find the result for the request"));
+		});
+	}
+	sendRequest(method, ...params) {
+		if (!rpcResult[method]) return Promise.reject(/* @__PURE__ */ 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;
+			this.handleBatch();
+		}, 0);
+		return deferred.promise.catch((error) => {
+			if (error instanceof Error) {
+				if (this.archiveNodeUrl && error.message.includes("Unknown block: State already discarded")) {
+					this.eventTarget.dispatchEvent(new CustomEvent("archiveNodeFallback", { detail: {
+						method,
+						params
+					} }));
+					return new this.constructor(this.archiveNodeUrl).sendRequest(method, ...params);
+				}
+				Error.captureStackTrace(error);
+			}
+			throw error;
+		});
+	}
+	methods() {
+		return Object.keys(rpcResult).sort();
+	}
 };
+
+//#endregion
+export { Client as default };

package/dist/HttpClient.cjs

@@ -1,34 +1,35 @@
-"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 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) {
-      this.handleErrorResponse(new Error(`HTTP error: ${res.status}`), requestMap);
-      return;
-    }
-    try {
-      const jsonRpcResponse = await res.json();
-      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);
-    }
-  }
-};
+const require_Client = require('./Client.cjs');
 
+//#region src/HttpClient.ts
+var HttpClient = class extends require_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;
+		}
+		if (!res.ok) {
+			this.handleErrorResponse(/* @__PURE__ */ new Error(`HTTP error: ${res.status}`), requestMap);
+			return;
+		}
+		try {
+			const jsonRpcResponse = await res.json();
+			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);
+		}
+	}
+};
 
-exports.default = HttpClient;
+//#endregion
+module.exports = HttpClient;

package/dist/HttpClient.d.cts

@@ -1,13 +1,8 @@
-import Client, { RequestMap } from './Client.cjs';
-import { RpcMethod, JsonRpcRequest } from './common.cjs';
-import '@chainflip/utils/async';
-import '@chainflip/utils/chainflip';
-import '@chainflip/utils/types';
-import 'zod';
-import './parsers.cjs';
+import { JsonRpcRequest, RpcMethod } from "./common.cjs";
+import Client, { RequestMap } from "./Client.cjs";
 
+//#region src/HttpClient.d.ts
 declare class HttpClient extends Client {
-    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>[], requestMap: RequestMap): Promise<void>;
+  protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>[], requestMap: RequestMap): Promise<void>;
 }
-
-export { HttpClient as default };
+export = HttpClient;

package/dist/HttpClient.d.mts

@@ -0,0 +1,9 @@
+import { JsonRpcRequest, RpcMethod } from "./common.mjs";
+import Client, { RequestMap } from "./Client.mjs";
+
+//#region src/HttpClient.d.ts
+declare class HttpClient extends Client {
+  protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>[], requestMap: RequestMap): Promise<void>;
+}
+//#endregion
+export { HttpClient as default };

package/dist/HttpClient.mjs

@@ -1,34 +1,35 @@
-// src/HttpClient.ts
 import Client from "./Client.mjs";
+
+//#region src/HttpClient.ts
 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;
-    }
-    if (!res.ok) {
-      this.handleErrorResponse(new Error(`HTTP error: ${res.status}`), requestMap);
-      return;
-    }
-    try {
-      const jsonRpcResponse = await res.json();
-      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);
-    }
-  }
-};
-export {
-  HttpClient as 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) {
+			this.handleErrorResponse(/* @__PURE__ */ new Error(`HTTP error: ${res.status}`), requestMap);
+			return;
+		}
+		try {
+			const jsonRpcResponse = await res.json();
+			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);
+		}
+	}
 };
+
+//#endregion
+export { HttpClient as default };