@chainflip/rpc 1.8.8 → 1.9.0-assethub.1

package/dist/WsClient.cjs

@@ -1,124 +1,113 @@
 "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 {
+  constructor(url, WebSocket = globalThis.WebSocket) {
+    super(url);_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);;
+    this.WebSocket = WebSocket;
+  }
   
   __init() {this.reconnectAttempts = 0}
   __init2() {this.emitter = new EventTarget()}
-  __init3() {this.inFlightRequestMap = /* @__PURE__ */ new Map()}
-  
-  __init4() {this.shouldConnect = true}
-  constructor(url, { timeout = 3e4 } = {}) {
-    super(url);_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;
-  }
+  __init3() {this.requestMap = /* @__PURE__ */ new Map()}
   async close() {
-    this.shouldConnect = false;
-    if (!this.ws) return;
-    await this.handleDisconnect();
-    const waitForClose = this.ws.readyState === WebSocket.OPEN;
+    await this.handleClose();
+  }
+  async handleClose() {
+    if (!this.ws)
+      return;
+    this.ws.removeEventListener("close", this.handleDisconnect);
     this.ws.close();
-    if (waitForClose) await _async.once.call(void 0, this.ws, "close");
-    this.ws = void 0;
+    if (this.ws.readyState !== this.WebSocket.CLOSED) {
+      await _async.once.call(void 0, this.ws, "close");
+    }
   }
   async connectionReady() {
     if (!this.ws) {
       return this.connect();
     }
-    if (this.ws.readyState !== WebSocket.OPEN) {
+    if (this.ws.readyState !== this.WebSocket.OPEN) {
       await _async.once.call(void 0, this.emitter, READY, { timeout: 3e4 });
     }
     return this.ws;
   }
-  __init5() {this.handleDisconnect = async () => {
+  __init4() {this.handleDisconnect = async () => {
     this.emitter.dispatchEvent(new Event(DISCONNECT));
-    this.inFlightRequestMap.forEach((request) => {
+    this.requestMap.forEach((request) => {
       request.reject(new Error("disconnected"));
     });
-    this.inFlightRequestMap.clear();
-    if (!this.shouldConnect) return;
+    this.requestMap.clear();
     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) => {
+  __init5() {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)]);
-    }
+    const response = _commoncjs.rpcResponse.safeParse(parsedData);
+    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)]);
   }}
   async connect() {
-    this.shouldConnect = true;
-    this.emitter.dispatchEvent(new Event(CONNECTING));
-    const socket = new WebSocket(this.url);
+    const socket = new this.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;
+    await _async.once.call(void 0, this.ws, "open", { timeout: 3e4 });
     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") })
+  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") })
           ),
-          result.promise.then(
-            (r) => ({ id, success: true, result: r }),
-            (error) => ({ id, success: false, error })
+          request.promise.then(
+            (result2) => ({ success: true, result: result2 }),
+            (error) => ({ success: false, error, retry: true })
           )
-        ]).then((response) => {
-          this.handleResponse(response, requestMap);
-        }).finally(() => {
-          this.inFlightRequestMap.delete(id);
+        ]).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
+          });
+        }
+      }
     }
-    await Promise.all(promises);
+    return responses;
   }
 }, _class);
 

package/dist/WsClient.d.cts

@@ -1,26 +1,23 @@
-import Client, { RequestMap } from './Client.cjs';
-import { JsonRpcRequest, RpcMethod } from './common.cjs';
-import '@chainflip/utils/async';
+import Client, { Response } from './Client.cjs';
+import { RpcMethod, JsonRpcRequest } from './common.cjs';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.cjs';
 
 declare class WsClient extends Client {
+    private readonly WebSocket;
     private ws?;
     private reconnectAttempts;
     private emitter;
-    private inFlightRequestMap;
-    private readonly timeout;
-    private shouldConnect;
-    constructor(url: string, { timeout }?: {
-        timeout?: number;
-    });
+    private requestMap;
+    constructor(url: string, WebSocket?: typeof globalThis.WebSocket);
     close(): Promise<void>;
+    private handleClose;
     private connectionReady;
     private handleDisconnect;
     private handleMessage;
     private connect;
-    protected send(requests: JsonRpcRequest<RpcMethod>[], requestMap: RequestMap): Promise<void>;
+    protected send<const T extends RpcMethod>(requests: JsonRpcRequest<T>[]): Promise<Response[]>;
 }
 
 export { WsClient as default };

package/dist/WsClient.d.ts

@@ -1,26 +1,23 @@
-import Client, { RequestMap } from './Client.js';
-import { JsonRpcRequest, RpcMethod } from './common.js';
-import '@chainflip/utils/async';
+import Client, { Response } from './Client.js';
+import { RpcMethod, JsonRpcRequest } from './common.js';
 import '@chainflip/utils/types';
 import 'zod';
 import './parsers.js';
 
 declare class WsClient extends Client {
+    private readonly WebSocket;
     private ws?;
     private reconnectAttempts;
     private emitter;
-    private inFlightRequestMap;
-    private readonly timeout;
-    private shouldConnect;
-    constructor(url: string, { timeout }?: {
-        timeout?: number;
-    });
+    private requestMap;
+    constructor(url: string, WebSocket?: typeof globalThis.WebSocket);
     close(): Promise<void>;
+    private handleClose;
     private connectionReady;
     private handleDisconnect;
     private handleMessage;
     private connect;
-    protected send(requests: JsonRpcRequest<RpcMethod>[], requestMap: RequestMap): Promise<void>;
+    protected send<const T extends RpcMethod>(requests: JsonRpcRequest<T>[]): Promise<Response[]>;
 }
 
 export { WsClient as default };

package/dist/WsClient.mjs

@@ -1,47 +1,45 @@
 // src/WsClient.ts
 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";
 var WsClient = class extends Client {
+  constructor(url, WebSocket = globalThis.WebSocket) {
+    super(url);
+    this.WebSocket = WebSocket;
+  }
   ws;
   reconnectAttempts = 0;
   emitter = new EventTarget();
-  inFlightRequestMap = /* @__PURE__ */ new Map();
-  timeout;
-  shouldConnect = true;
-  constructor(url, { timeout = 3e4 } = {}) {
-    super(url);
-    this.timeout = timeout;
-  }
+  requestMap = /* @__PURE__ */ new Map();
   async close() {
-    this.shouldConnect = false;
-    if (!this.ws) return;
-    await this.handleDisconnect();
-    const waitForClose = this.ws.readyState === WebSocket.OPEN;
+    await this.handleClose();
+  }
+  async handleClose() {
+    if (!this.ws)
+      return;
+    this.ws.removeEventListener("close", this.handleDisconnect);
     this.ws.close();
-    if (waitForClose) await once(this.ws, "close");
-    this.ws = void 0;
+    if (this.ws.readyState !== this.WebSocket.CLOSED) {
+      await once(this.ws, "close");
+    }
   }
   async connectionReady() {
     if (!this.ws) {
       return this.connect();
     }
-    if (this.ws.readyState !== WebSocket.OPEN) {
+    if (this.ws.readyState !== this.WebSocket.OPEN) {
       await once(this.emitter, READY, { timeout: 3e4 });
     }
     return this.ws;
   }
   handleDisconnect = async () => {
     this.emitter.dispatchEvent(new Event(DISCONNECT));
-    this.inFlightRequestMap.forEach((request) => {
+    this.requestMap.forEach((request) => {
       request.reject(new Error("disconnected"));
     });
-    this.inFlightRequestMap.clear();
-    if (!this.shouldConnect) return;
+    this.requestMap.clear();
     const backoff = 250 * 2 ** this.reconnectAttempts;
     await sleep(backoff);
     await this.connect().catch(() => {
@@ -50,75 +48,66 @@ var WsClient = class extends Client {
   };
   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);
-    }
+    const response = rpcResponse.safeParse(parsedData);
+    if (!response.success)
+      return;
+    const { id } = response.data;
+    this.requestMap.get(id)?.resolve(response.data);
   };
   async connect() {
-    this.shouldConnect = true;
-    this.emitter.dispatchEvent(new Event(CONNECTING));
-    const socket = new WebSocket(this.url);
+    const socket = new this.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;
+    await once(this.ws, "open", { timeout: 3e4 });
     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") })
+  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") })
           ),
-          result.promise.then(
-            (r) => ({ id, success: true, result: r }),
-            (error) => ({ id, success: false, error })
+          request.promise.then(
+            (result2) => ({ success: true, result: result2 }),
+            (error) => ({ success: false, error, retry: true })
           )
-        ]).then((response) => {
-          this.handleResponse(response, requestMap);
-        }).finally(() => {
-          this.inFlightRequestMap.delete(id);
+        ]).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
+          });
+        }
+      }
     }
-    await Promise.all(promises);
+    return responses;
   }
 };
 export {

package/dist/common.cjs

@@ -16,9 +16,6 @@
 
 
 
-
-
-
 
 
 
@@ -26,9 +23,7 @@
 var _parserscjs = require('./parsers.cjs');
 
 var rpcResult = {
-  broker_request_swap_deposit_address: _parserscjs.brokerRequestSwapDepositAddress,
-  broker_request_swap_parameter_encoding: _parserscjs.requestSwapParameterEncoding,
-  cf_request_swap_parameter_encoding: _parserscjs.requestSwapParameterEncoding,
+  broker_requestSwapDepositAddress: _parserscjs.brokerRequestSwapDepositAddress,
   cf_accounts: _parserscjs.cfAccounts,
   cf_account_info: _parserscjs.cfAccountInfo,
   cf_pool_depth: _parserscjs.cfPoolDepth,
@@ -42,14 +37,12 @@ var rpcResult = {
   cf_supported_assets: _parserscjs.cfSupportedAssets,
   cf_swap_rate: _parserscjs.cfSwapRate,
   cf_swap_rate_v2: _parserscjs.cfSwapRateV2,
-  cf_swap_rate_v3: _parserscjs.cfSwapRateV3,
   cf_swapping_environment: _parserscjs.cfSwappingEnvironment,
   chain_getBlockHash: _parserscjs.chainGetBlockHash,
   cf_boost_pool_details: _parserscjs.cfBoostPoolDetails,
   cf_boost_pool_pending_fees: _parserscjs.cfBoostPoolPendingFees,
   state_getMetadata: _parserscjs.stateGetMetadata,
-  state_getRuntimeVersion: _parserscjs.stateGetRuntimeVersion,
-  lp_total_balances: _parserscjs.lpTotalBalances
+  state_getRuntimeVersion: _parserscjs.stateGetRuntimeVersion
 };