@chainflip/rpc 2.0.7 → 2.1.0-beta.0

package/dist/WsClient.cjs

@@ -1,126 +1,121 @@
-"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 {
-  
-  __init() {this.reconnectAttempts = 0}
-  __init2() {this.emitter = new EventTarget()}
-  __init3() {this.inFlightRequestMap = /* @__PURE__ */ new Map()}
-  
-  __init4() {this.shouldConnect = true}
-  constructor(url, { timeout = 3e4, ...opts } = {}) {
-    super(url, opts);_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 close() {
-    this.shouldConnect = false;
-    if (!this.ws) return;
-    await this.handleDisconnect();
-    const waitForClose = this.ws.readyState === WebSocket.OPEN;
-    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 !== WebSocket.OPEN) {
-      await _async.once.call(void 0, this.emitter, READY, { timeout: 3e4 });
-    }
-    return this.ws;
-  }
-  __init5() {this.handleDisconnect = async () => {
-    this.emitter.dispatchEvent(new Event(DISCONNECT));
-    this.inFlightRequestMap.forEach((request) => {
-      request.reject(new Error("disconnected"));
-    });
-    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);
-    });
-  }}
-  __init6() {this.handleMessage = (data) => {
-    const parsedData = JSON.parse(data.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() {
-    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 });
-    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, 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") })
-          ),
-          result.promise.then(
-            (r) => ({ id, success: true, result: r }),
-            (error) => ({ id, success: false, error })
-          )
-        ]).then((response) => {
-          this.handleResponse(response, requestMap);
-        }).finally(() => {
-          this.inFlightRequestMap.delete(id);
-          controller.abort();
-        })
-      );
-    }
-    await Promise.all(promises);
-  }
-}, _class);
+const require_parsers = require('./parsers.cjs');
+require('./common.cjs');
+const require_Client = require('./Client.cjs');
+let _chainflip_utils_async = require("@chainflip/utils/async");
+let zod = require("zod");
 
+//#region src/WsClient.ts
+const CONNECTING = "CONNECTING";
+const READY = "READY";
+const DISCONNECT = "DISCONNECT";
+var WsClient = class extends require_Client {
+	ws;
+	reconnectAttempts = 0;
+	emitter = new EventTarget();
+	inFlightRequestMap = /* @__PURE__ */ new Map();
+	timeout;
+	shouldConnect = true;
+	constructor(url, { timeout = 3e4, ...opts } = {}) {
+		super(url, opts);
+		this.timeout = timeout;
+	}
+	async close() {
+		this.shouldConnect = false;
+		if (!this.ws) return;
+		await this.handleDisconnect();
+		const waitForClose = this.ws.readyState === WebSocket.OPEN;
+		this.ws.close();
+		if (waitForClose) await (0, _chainflip_utils_async.once)(this.ws, "close");
+		this.ws = void 0;
+	}
+	async connectionReady() {
+		if (!this.ws) return this.connect();
+		if (this.ws.readyState !== WebSocket.OPEN) await (0, _chainflip_utils_async.once)(this.emitter, READY, { timeout: 3e4 });
+		return this.ws;
+	}
+	handleDisconnect = async () => {
+		this.emitter.dispatchEvent(new Event(DISCONNECT));
+		this.inFlightRequestMap.forEach((request) => {
+			request.reject(/* @__PURE__ */ new Error("disconnected"));
+		});
+		this.inFlightRequestMap.clear();
+		if (!this.shouldConnect) return;
+		await (0, _chainflip_utils_async.sleep)(250 * 2 ** this.reconnectAttempts);
+		await this.connect().catch(() => {
+			this.reconnectAttempts = Math.min(this.reconnectAttempts + 1, 6);
+		});
+	};
+	handleMessage = (data) => {
+		const parsedData = JSON.parse(data.data);
+		const responses = zod.z.array(require_parsers.rpcResponse).safeParse(parsedData);
+		if (!responses.success) return;
+		for (const response of responses.data) {
+			const { id } = response;
+			this.inFlightRequestMap.get(id)?.resolve(response);
+		}
+	};
+	async connect() {
+		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) this.handleDisconnect();
+		};
+		this.ws.addEventListener("close", this.handleDisconnect, { once: true });
+		this.ws.addEventListener("error", handleConnectionError, { once: true });
+		await (0, _chainflip_utils_async.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, 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(/* @__PURE__ */ new Error("failed to connect"), requestMap);
+			return;
+		}
+		socket.send(JSON.stringify(requests));
+		const promises = [];
+		for (const [id] of requestMap) {
+			const result = (0, _chainflip_utils_async.deferredPromise)();
+			const controller = new AbortController();
+			this.inFlightRequestMap.set(id, result);
+			promises.push(Promise.race([(0, _chainflip_utils_async.sleep)(this.timeout, { signal: controller.signal }).then(() => ({
+				id,
+				success: false,
+				error: /* @__PURE__ */ new Error("timeout")
+			})), result.promise.then((r) => ({
+				id,
+				success: true,
+				result: r
+			}), (error) => ({
+				id,
+				success: false,
+				error
+			}))]).then((response) => {
+				this.handleResponse(response, requestMap);
+			}).finally(() => {
+				this.inFlightRequestMap.delete(id);
+				controller.abort();
+			}));
+		}
+		await Promise.all(promises);
+	}
+};
 
-exports.default = WsClient;
+//#endregion
+module.exports = WsClient;

package/dist/WsClient.d.ts

@@ -1,27 +1,25 @@
-import Client, { ClientOpts, RequestMap } from './Client.js';
-import { JsonRpcRequest, RpcMethod } from './common.js';
-import '@chainflip/utils/async';
-import '@chainflip/utils/chainflip';
-import '@chainflip/utils/types';
-import 'zod';
-import './parsers.js';
+import { JsonRpcRequest, RpcMethod } from "./common.js";
+import Client, { ClientOpts, RequestMap } from "./Client.js";
 
+//#region src/WsClient.d.ts
 declare class WsClient extends Client {
-    private ws?;
-    private reconnectAttempts;
-    private emitter;
-    private inFlightRequestMap;
-    private readonly timeout;
-    private shouldConnect;
-    constructor(url: string, { timeout, ...opts }?: {
-        timeout?: number;
-    } & ClientOpts);
-    close(): Promise<void>;
-    private connectionReady;
-    private handleDisconnect;
-    private handleMessage;
-    private connect;
-    protected send(requests: JsonRpcRequest<RpcMethod>[], requestMap: RequestMap): Promise<void>;
+  private ws?;
+  private reconnectAttempts;
+  private emitter;
+  private inFlightRequestMap;
+  private readonly timeout;
+  private shouldConnect;
+  constructor(url: string, {
+    timeout,
+    ...opts
+  }?: {
+    timeout?: number;
+  } & ClientOpts);
+  close(): Promise<void>;
+  private connectionReady;
+  private handleDisconnect;
+  private handleMessage;
+  private connect;
+  protected send(requests: JsonRpcRequest<RpcMethod>[], requestMap: RequestMap): Promise<void>;
 }
-
-export { WsClient as default };
+export = WsClient;

package/dist/WsClient.mjs

@@ -1,126 +1,121 @@
-// src/WsClient.ts
+import { rpcResponse } from "./parsers.mjs";
+import "./common.mjs";
+import Client from "./Client.mjs";
 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";
+
+//#region src/WsClient.ts
+const CONNECTING = "CONNECTING";
+const READY = "READY";
+const DISCONNECT = "DISCONNECT";
 var WsClient = class extends Client {
-  ws;
-  reconnectAttempts = 0;
-  emitter = new EventTarget();
-  inFlightRequestMap = /* @__PURE__ */ new Map();
-  timeout;
-  shouldConnect = true;
-  constructor(url, { timeout = 3e4, ...opts } = {}) {
-    super(url, opts);
-    this.timeout = timeout;
-  }
-  async close() {
-    this.shouldConnect = false;
-    if (!this.ws) return;
-    await this.handleDisconnect();
-    const waitForClose = this.ws.readyState === WebSocket.OPEN;
-    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 !== WebSocket.OPEN) {
-      await once(this.emitter, READY, { timeout: 3e4 });
-    }
-    return this.ws;
-  }
-  handleDisconnect = async () => {
-    this.emitter.dispatchEvent(new Event(DISCONNECT));
-    this.inFlightRequestMap.forEach((request) => {
-      request.reject(new Error("disconnected"));
-    });
-    this.inFlightRequestMap.clear();
-    if (!this.shouldConnect) return;
-    const backoff = 250 * 2 ** this.reconnectAttempts;
-    await sleep(backoff);
-    await this.connect().catch(() => {
-      this.reconnectAttempts = Math.min(this.reconnectAttempts + 1, 6);
-    });
-  };
-  handleMessage = (data) => {
-    const parsedData = JSON.parse(data.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() {
-    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 });
-    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, 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") })
-          ),
-          result.promise.then(
-            (r) => ({ id, success: true, result: r }),
-            (error) => ({ id, success: false, error })
-          )
-        ]).then((response) => {
-          this.handleResponse(response, requestMap);
-        }).finally(() => {
-          this.inFlightRequestMap.delete(id);
-          controller.abort();
-        })
-      );
-    }
-    await Promise.all(promises);
-  }
-};
-export {
-  WsClient as default
+	ws;
+	reconnectAttempts = 0;
+	emitter = new EventTarget();
+	inFlightRequestMap = /* @__PURE__ */ new Map();
+	timeout;
+	shouldConnect = true;
+	constructor(url, { timeout = 3e4, ...opts } = {}) {
+		super(url, opts);
+		this.timeout = timeout;
+	}
+	async close() {
+		this.shouldConnect = false;
+		if (!this.ws) return;
+		await this.handleDisconnect();
+		const waitForClose = this.ws.readyState === WebSocket.OPEN;
+		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 !== WebSocket.OPEN) await once(this.emitter, READY, { timeout: 3e4 });
+		return this.ws;
+	}
+	handleDisconnect = async () => {
+		this.emitter.dispatchEvent(new Event(DISCONNECT));
+		this.inFlightRequestMap.forEach((request) => {
+			request.reject(/* @__PURE__ */ new Error("disconnected"));
+		});
+		this.inFlightRequestMap.clear();
+		if (!this.shouldConnect) return;
+		await sleep(250 * 2 ** this.reconnectAttempts);
+		await this.connect().catch(() => {
+			this.reconnectAttempts = Math.min(this.reconnectAttempts + 1, 6);
+		});
+	};
+	handleMessage = (data) => {
+		const parsedData = JSON.parse(data.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() {
+		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) this.handleDisconnect();
+		};
+		this.ws.addEventListener("close", this.handleDisconnect, { once: true });
+		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, 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(/* @__PURE__ */ 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: /* @__PURE__ */ new Error("timeout")
+			})), result.promise.then((r) => ({
+				id,
+				success: true,
+				result: r
+			}), (error) => ({
+				id,
+				success: false,
+				error
+			}))]).then((response) => {
+				this.handleResponse(response, requestMap);
+			}).finally(() => {
+				this.inFlightRequestMap.delete(id);
+				controller.abort();
+			}));
+		}
+		await Promise.all(promises);
+	}
 };
+
+//#endregion
+export { WsClient as default };

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,19 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+
+exports.__exportAll = __exportAll;

package/dist/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,18 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll };