@chainflip/rpc 1.4.0

package/dist/Client.cjs

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _common = require('./common');
+var _assertion = require('@chainflip/utils/assertion');
+class Client {
+  constructor(url) {
+    this.url = url;
+  }
+  getRequestId() {
+    return "1";
+  }
+  formatRequest(method, params) {
+    return { jsonrpc: "2.0", id: this.getRequestId(), method, params };
+  }
+  async sendRequest(method, ...params) {
+    const response = await this.send(this.formatRequest(method, params));
+    if (!response.success)
+      throw response.error;
+    const parseResult = _common.rpcResponse.safeParse(response.result);
+    _assertion.assert.call(void 0, parseResult.success, "Malformed RPC response received");
+    if ("error" in parseResult.data) {
+      throw new Error(
+        `RPC error [${parseResult.data.error.code}]: ${parseResult.data.error.message}`
+      );
+    }
+    return _common.rpcResult[method].parse(parseResult.data.result);
+  }
+  methods() {
+    return Object.keys(_common.rpcResult).sort();
+  }
+}
+
+
+exports.default = Client;

package/dist/Client.d.cts

@@ -0,0 +1,22 @@
+import { RpcMethod, JsonRpcRequest, RpcRequest, RpcResult } from './common.cjs';
+import 'zod';
+import './parsers.cjs';
+import '@chainflip/utils/types';
+
+declare abstract class Client {
+    protected readonly url: string;
+    constructor(url: string);
+    protected abstract send<const T extends RpcMethod>(data: JsonRpcRequest<T>): Promise<{
+        success: true;
+        result: unknown;
+    } | {
+        success: false;
+        error: Error;
+    }>;
+    protected getRequestId(): string;
+    private formatRequest;
+    sendRequest<const T extends RpcMethod>(method: T, ...params: RpcRequest[T]): Promise<RpcResult<T>>;
+    methods(): RpcMethod[];
+}
+
+export { Client as default };

package/dist/Client.d.ts

@@ -0,0 +1,22 @@
+import { RpcMethod, JsonRpcRequest, RpcRequest, RpcResult } from './common.js';
+import 'zod';
+import './parsers.js';
+import '@chainflip/utils/types';
+
+declare abstract class Client {
+    protected readonly url: string;
+    constructor(url: string);
+    protected abstract send<const T extends RpcMethod>(data: JsonRpcRequest<T>): Promise<{
+        success: true;
+        result: unknown;
+    } | {
+        success: false;
+        error: Error;
+    }>;
+    protected getRequestId(): string;
+    private formatRequest;
+    sendRequest<const T extends RpcMethod>(method: T, ...params: RpcRequest[T]): Promise<RpcResult<T>>;
+    methods(): RpcMethod[];
+}
+
+export { Client as default };

package/dist/Client.js

@@ -0,0 +1,32 @@
+import { rpcResult, rpcResponse } from "./common";
+import { assert } from "@chainflip/utils/assertion";
+class Client {
+  constructor(url) {
+    this.url = url;
+  }
+  getRequestId() {
+    return "1";
+  }
+  formatRequest(method, params) {
+    return { jsonrpc: "2.0", id: this.getRequestId(), method, params };
+  }
+  async sendRequest(method, ...params) {
+    const response = await this.send(this.formatRequest(method, params));
+    if (!response.success)
+      throw response.error;
+    const parseResult = rpcResponse.safeParse(response.result);
+    assert(parseResult.success, "Malformed RPC response received");
+    if ("error" in parseResult.data) {
+      throw new Error(
+        `RPC error [${parseResult.data.error.code}]: ${parseResult.data.error.message}`
+      );
+    }
+    return rpcResult[method].parse(parseResult.data.result);
+  }
+  methods() {
+    return Object.keys(rpcResult).sort();
+  }
+}
+export {
+  Client as default
+};

package/dist/HttpClient.cjs

@@ -0,0 +1,24 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _Client = require('./Client'); var _Client2 = _interopRequireDefault(_Client);
+class HttpClient extends _Client2.default {
+  async send(request) {
+    const res = await fetch(this.url, {
+      body: JSON.stringify(request),
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      return { success: false, error: new Error(`HTTP error: ${res.status}`) };
+    }
+    try {
+      const result = await res.json();
+      return { success: true, result };
+    } catch (error) {
+      return { success: false, error: new Error("Invalid JSON response") };
+    }
+  }
+}
+
+
+exports.default = HttpClient;

package/dist/HttpClient.d.cts

@@ -0,0 +1,17 @@
+import Client from './Client.cjs';
+import { RpcMethod, JsonRpcRequest } from './common.cjs';
+import 'zod';
+import './parsers.cjs';
+import '@chainflip/utils/types';
+
+declare class HttpClient extends Client {
+    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>): Promise<{
+        success: true;
+        result: unknown;
+    } | {
+        success: false;
+        error: Error;
+    }>;
+}
+
+export { HttpClient as default };

package/dist/HttpClient.d.ts

@@ -0,0 +1,17 @@
+import Client from './Client.js';
+import { RpcMethod, JsonRpcRequest } from './common.js';
+import 'zod';
+import './parsers.js';
+import '@chainflip/utils/types';
+
+declare class HttpClient extends Client {
+    protected send<const T extends RpcMethod>(request: JsonRpcRequest<T>): Promise<{
+        success: true;
+        result: unknown;
+    } | {
+        success: false;
+        error: Error;
+    }>;
+}
+
+export { HttpClient as default };

package/dist/HttpClient.js

@@ -0,0 +1,24 @@
+import Client from "./Client";
+class HttpClient extends Client {
+  async send(request) {
+    const res = await fetch(this.url, {
+      body: JSON.stringify(request),
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      return { success: false, error: new Error(`HTTP error: ${res.status}`) };
+    }
+    try {
+      const result = await res.json();
+      return { success: true, result };
+    } catch (error) {
+      return { success: false, error: new Error("Invalid JSON response") };
+    }
+  }
+}
+export {
+  HttpClient as default
+};

package/dist/WsClient.cjs

@@ -0,0 +1,107 @@
+"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 _async = require('@chainflip/utils/async');
+var _crypto = require('crypto');
+var _Client = require('./Client'); var _Client2 = _interopRequireDefault(_Client);
+var _common = require('./common');
+const READY = "READY";
+const DISCONNECT = "DISCONNECT";
+class WsClient extends _Client2.default {
+  constructor(url, WebSocket = globalThis.WebSocket) {
+    super(url);WsClient.prototype.__init.call(this);WsClient.prototype.__init2.call(this);WsClient.prototype.__init3.call(this);WsClient.prototype.__init4.call(this);WsClient.prototype.__init5.call(this);;
+    this.WebSocket = WebSocket;
+  }
+  
+  __init() {this.reconnectAttempts = 0}
+  __init2() {this.emitter = new EventTarget()}
+  __init3() {this.requestMap = /* @__PURE__ */ new Map()}
+  getRequestId() {
+    return _crypto.randomUUID.call(void 0, );
+  }
+  async close() {
+    await this.handleClose();
+  }
+  async handleClose() {
+    if (!this.ws)
+      return;
+    this.ws.removeEventListener("close", this.handleDisconnect);
+    this.ws.close();
+    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 !== this.WebSocket.OPEN) {
+      await _async.once.call(void 0, this.emitter, READY, { timeout: 3e4 });
+    }
+    return this.ws;
+  }
+  __init4() {this.handleDisconnect = async () => {
+    this.emitter.dispatchEvent(new Event(DISCONNECT));
+    this.requestMap.forEach((request) => {
+      request.reject(new Error("disconnected"));
+    });
+    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);
+    });
+  }}
+  __init5() {this.handleMessage = (data) => {
+    const parsedData = JSON.parse(data.data);
+    const response = _common.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() {
+    const socket = new this.WebSocket(this.url);
+    this.ws = socket;
+    this.ws.addEventListener("message", this.handleMessage);
+    this.ws.addEventListener("close", this.handleDisconnect, { once: 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.reconnectAttempts = 0;
+    return socket;
+  }
+  async send(data) {
+    let requestId = data.id;
+    for (let i = 0; i < 5; i += 1) {
+      let socket;
+      try {
+        socket = await this.connectionReady();
+      } catch (err) {
+        continue;
+      }
+      socket.send(JSON.stringify({ ...data, id: requestId }));
+      const request = _async.deferredPromise.call(void 0, );
+      this.requestMap.set(requestId, 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") })
+        ),
+        request.promise.then(
+          (result2) => ({ success: true, result: result2 }),
+          (error) => ({ success: false, error, retry: true })
+        )
+      ]).finally(() => {
+        this.requestMap.delete(requestId);
+        controller.abort();
+      });
+      if (result.success || !result.retry)
+        return result;
+      requestId = this.getRequestId();
+    }
+    return { success: false, error: new Error("max retries exceeded") };
+  }
+}
+
+
+exports.default = WsClient;

package/dist/WsClient.d.cts

@@ -0,0 +1,30 @@
+import Client from './Client.cjs';
+import { RpcMethod, JsonRpcRequest } from './common.cjs';
+import 'zod';
+import './parsers.cjs';
+import '@chainflip/utils/types';
+
+declare class WsClient extends Client {
+    private readonly WebSocket;
+    private ws?;
+    private reconnectAttempts;
+    private emitter;
+    private requestMap;
+    constructor(url: string, WebSocket?: typeof globalThis.WebSocket);
+    protected getRequestId(): `${string}-${string}-${string}-${string}-${string}`;
+    close(): Promise<void>;
+    private handleClose;
+    private connectionReady;
+    private handleDisconnect;
+    private handleMessage;
+    private connect;
+    protected send<const T extends RpcMethod>(data: JsonRpcRequest<T>): Promise<{
+        success: true;
+        result: unknown;
+    } | {
+        success: false;
+        error: Error;
+    }>;
+}
+
+export { WsClient as default };

package/dist/WsClient.d.ts

@@ -0,0 +1,30 @@
+import Client from './Client.js';
+import { RpcMethod, JsonRpcRequest } from './common.js';
+import 'zod';
+import './parsers.js';
+import '@chainflip/utils/types';
+
+declare class WsClient extends Client {
+    private readonly WebSocket;
+    private ws?;
+    private reconnectAttempts;
+    private emitter;
+    private requestMap;
+    constructor(url: string, WebSocket?: typeof globalThis.WebSocket);
+    protected getRequestId(): `${string}-${string}-${string}-${string}-${string}`;
+    close(): Promise<void>;
+    private handleClose;
+    private connectionReady;
+    private handleDisconnect;
+    private handleMessage;
+    private connect;
+    protected send<const T extends RpcMethod>(data: JsonRpcRequest<T>): Promise<{
+        success: true;
+        result: unknown;
+    } | {
+        success: false;
+        error: Error;
+    }>;
+}
+
+export { WsClient as default };

package/dist/WsClient.js

@@ -0,0 +1,107 @@
+import { deferredPromise, once, sleep } from "@chainflip/utils/async";
+import { randomUUID } from "crypto";
+import Client from "./Client";
+import { rpcResponse } from "./common";
+const READY = "READY";
+const DISCONNECT = "DISCONNECT";
+class WsClient extends Client {
+  constructor(url, WebSocket = globalThis.WebSocket) {
+    super(url);
+    this.WebSocket = WebSocket;
+  }
+  ws;
+  reconnectAttempts = 0;
+  emitter = new EventTarget();
+  requestMap = /* @__PURE__ */ new Map();
+  getRequestId() {
+    return randomUUID();
+  }
+  async close() {
+    await this.handleClose();
+  }
+  async handleClose() {
+    if (!this.ws)
+      return;
+    this.ws.removeEventListener("close", this.handleDisconnect);
+    this.ws.close();
+    if (this.ws.readyState !== this.WebSocket.CLOSED) {
+      await once(this.ws, "close");
+    }
+  }
+  async connectionReady() {
+    if (!this.ws) {
+      return this.connect();
+    }
+    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.requestMap.forEach((request) => {
+      request.reject(new Error("disconnected"));
+    });
+    this.requestMap.clear();
+    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 response = rpcResponse.safeParse(parsedData);
+    if (!response.success)
+      return;
+    const { id } = response.data;
+    this.requestMap.get(id)?.resolve(response.data);
+  };
+  async connect() {
+    const socket = new this.WebSocket(this.url);
+    this.ws = socket;
+    this.ws.addEventListener("message", this.handleMessage);
+    this.ws.addEventListener("close", this.handleDisconnect, { once: true });
+    await once(this.ws, "open", { timeout: 3e4 });
+    this.ws.addEventListener("error", () => {
+      socket.close();
+    });
+    this.emitter.dispatchEvent(new Event(READY));
+    this.reconnectAttempts = 0;
+    return socket;
+  }
+  async send(data) {
+    let requestId = data.id;
+    for (let i = 0; i < 5; i += 1) {
+      let socket;
+      try {
+        socket = await this.connectionReady();
+      } catch (err) {
+        continue;
+      }
+      socket.send(JSON.stringify({ ...data, id: requestId }));
+      const request = deferredPromise();
+      this.requestMap.set(requestId, request);
+      const controller = new AbortController();
+      const result = await Promise.race([
+        sleep(3e4, { signal: controller.signal }).then(
+          () => ({ success: false, retry: false, error: new Error("timeout") })
+        ),
+        request.promise.then(
+          (result2) => ({ success: true, result: result2 }),
+          (error) => ({ success: false, error, retry: true })
+        )
+      ]).finally(() => {
+        this.requestMap.delete(requestId);
+        controller.abort();
+      });
+      if (result.success || !result.retry)
+        return result;
+      requestId = this.getRequestId();
+    }
+    return { success: false, error: new Error("max retries exceeded") };
+  }
+}
+export {
+  WsClient as default
+};

package/dist/common.cjs

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+var _parsers = require('./parsers');
+const rpcResult = {
+  broker_requestSwapDepositAddress: _parsers.brokerRequestSwapDepositAddress,
+  cf_boost_pools_depth: _parsers.cfBoostPoolsDepth,
+  cf_environment: _parsers.cfEnvironment,
+  cf_funding_environment: _parsers.cfFundingEnvironment,
+  cf_ingress_egress_environment: _parsers.cfIngressEgressEnvironment,
+  cf_supported_assets: _parsers.cfSupportedAsssets,
+  cf_swap_rate: _parsers.cfSwapRate,
+  cf_swap_rate_v2: _parsers.cfSwapRateV2,
+  cf_swapping_environment: _parsers.cfSwappingEnvironment,
+  chain_getBlockHash: _parsers.chainGetBlockHash,
+  state_getMetadata: _parsers.stateGetMetadata,
+  state_getRuntimeVersion: _parsers.stateGetRuntimeVersion
+};
+
+
+
+
+exports.rpcResponse = _parsers.rpcResponse; exports.rpcResult = rpcResult;