@chainflip/rpc 1.9.0-assethub.1 → 1.9.1

package/dist/WsClient.cjs

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

package/dist/WsClient.d.cts

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

package/dist/WsClient.d.ts

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

package/dist/WsClient.mjs

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

package/dist/common.cjs

@@ -1,4 +1,14 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/common.ts
+var _zod = require('zod');
+
+
+
+
+
+
+
+
+
 
 
 
@@ -23,7 +33,9 @@
 var _parserscjs = require('./parsers.cjs');
 
 var rpcResult = {
-  broker_requestSwapDepositAddress: _parserscjs.brokerRequestSwapDepositAddress,
+  broker_request_swap_deposit_address: _parserscjs.brokerRequestSwapDepositAddress,
+  broker_request_swap_parameter_encoding: _parserscjs.requestSwapParameterEncoding,
+  cf_request_swap_parameter_encoding: _parserscjs.requestSwapParameterEncoding,
   cf_accounts: _parserscjs.cfAccounts,
   cf_account_info: _parserscjs.cfAccountInfo,
   cf_pool_depth: _parserscjs.cfPoolDepth,
@@ -37,12 +49,23 @@ 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
+  state_getRuntimeVersion: _parserscjs.stateGetRuntimeVersion,
+  lp_total_balances: _parserscjs.lpTotalBalances,
+  cf_failed_call_ethereum: _parserscjs.cfFailedCallEvm.nullable(),
+  cf_failed_call_arbitrum: _parserscjs.cfFailedCallEvm.nullable(),
+  cf_authority_emission_per_block: _parserscjs.numberOrHex,
+  cf_epoch_duration: _zod.z.number(),
+  cf_auction_state: _parserscjs.cfAuctionState,
+  cf_flip_supply: _parserscjs.cfFlipSuppy,
+  cf_eth_state_chain_gateway_address: _parserscjs.ethereumAddress.nullable(),
+  cf_eth_key_manager_address: _parserscjs.ethereumAddress.nullable(),
+  cf_pool_orderbook: _parserscjs.cfPoolOrderbook
 };