@electrum-cash/network 3.3.1-development.6372294997 → 4.0.0-development.6391574314

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {EventEmitter as $4QiMX$EventEmitter} from "events";
 import {Mutex as $4QiMX$Mutex} from "async-mutex";
 import $4QiMX$debug from "debug";
-import {parse as $4QiMX$parse, parseNumberAndBigInt as $4QiMX$parseNumberAndBigInt, stringify as $4QiMX$stringify} from "lossless-json";
+import {parse as $4QiMX$parse, parseNumberAndBigInt as $4QiMX$parseNumberAndBigInt} from "lossless-json";
 import {connect as $4QiMX$connect, TLSSocket as $4QiMX$TLSSocket} from "tls";
 import {isIP as $4QiMX$isIP, connect as $4QiMX$connect1} from "net";
 import {WebSocket as $4QiMX$WebSocket} from "@monsterbitar/isomorphic-ws";
@@ -182,16 +182,7 @@ const $5abc8fb342687c03$export$f019be48b3aacb1a = {
 
 
 
-/**
- * Isomorphic Socket interface supporting TCP sockets and WebSockets (Node and browser).
- * The interface is a subset of the TLSSocket interface with some slight modifications.
- * It can be expanded when more socket functionality is needed in the rest of the
- * electrum-cash code. Changes from the TLSSocket interface (besides it being a subset):
- * - Event 'close' -> 'disconnect'
- * - New function socket.disconnect()
- *
- * @ignore
- */ class $ea64e414b68fe23b$var$ElectrumSocket extends (0, $4QiMX$EventEmitter) {
+class $ea64e414b68fe23b$export$22c0ca2c816c3e08 extends (0, $4QiMX$EventEmitter) {
     /**
 	 * Connect to host:port using the specified transport
 	 *
@@ -203,7 +194,7 @@ const $5abc8fb342687c03$export$f019be48b3aacb1a = {
 	 * @throws {Error} if an incorrect transport scheme is specified
 	 */ connect(host, port, scheme, timeout) {
         // Check that no existing socket exists before initiating a new connection.
-        if (this.tcpSocket || this.webSocket) throw new Error("Cannot initiate a new socket connection when an existing connection exists");
+        if (this.tcpSocket) throw new Error("Cannot initiate a new socket connection when an existing connection exists");
         // Set a timer to force disconnect after `timeout` seconds
         this.timers.disconnect = setTimeout(()=>this.disconnectOnTimeout(host, port, timeout), timeout);
         // Remove the timer if a connection is successfully established
@@ -211,65 +202,182 @@ const $5abc8fb342687c03$export$f019be48b3aacb1a = {
         // Define how to refer to the connection scheme in debug output.
         const socketTypes = {
             [(0, $5abc8fb342687c03$export$d048df559e6d3842).TCP.Scheme]: "a TCP Socket",
-            [(0, $5abc8fb342687c03$export$d048df559e6d3842).TCP_TLS.Scheme]: "an encrypted TCP socket",
+            [(0, $5abc8fb342687c03$export$d048df559e6d3842).TCP_TLS.Scheme]: "an encrypted TCP socket"
+        };
+        // Log that we are trying to establish a connection.
+        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).network(`Initiating ${socketTypes[scheme]} connection to '${host}:${port}'.`);
+        if (scheme !== (0, $5abc8fb342687c03$export$d048df559e6d3842).TCP.Scheme && scheme !== (0, $5abc8fb342687c03$export$d048df559e6d3842).TCP_TLS.Scheme) // Throw an error if an incorrect transport is specified
+        throw new Error("Incorrect transport specified");
+        if (scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).TCP_TLS.Scheme) {
+            // Initialize connection options.
+            const connectionOptions = {
+                rejectUnauthorized: false
+            };
+            // If the hostname is not an IP address..
+            if (!$4QiMX$isIP(host)) // Set the servername option which enables support for SNI.
+            // NOTE: SNI enables a server that hosts multiple domains to provide the appropriate TLS certificate.
+            connectionOptions.serverName = host;
+            // Initialize the socket (allowing self-signed certificates).
+            this.tcpSocket = $4QiMX$connect(port, host, connectionOptions);
+            // Add a 'secureConnect' listener that checks the authorization status of
+            // the socket, and logs a warning when it uses a self signed certificate.
+            this.tcpSocket.once("secureConnect", ()=>{
+                // Cannot happen, since this event callback *only* exists on TLSSocket
+                if (!(this.tcpSocket instanceof $4QiMX$TLSSocket)) return;
+                // Force cast authorizationError from Error to string (through unknown)
+                // because it is incorrectly typed as an Error
+                const authorizationError = this.tcpSocket.authorizationError;
+                if (authorizationError === "DEPTH_ZERO_SELF_SIGNED_CERT") (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).warning(`Connection to ${host}:${port} uses a self-signed certificate`);
+            });
+            // Trigger successful connection events.
+            this.tcpSocket.on("secureConnect", this.onConnect.bind(this, socketTypes[scheme], host, port));
+        } else {
+            // Initialize the socket.
+            this.tcpSocket = $4QiMX$connect1({
+                host: host,
+                port: port
+            });
+            // Trigger successful connection events.
+            this.tcpSocket.on("connect", this.onConnect.bind(this, socketTypes[scheme], host, port));
+        }
+        // Configure encoding.
+        this.tcpSocket.setEncoding("utf8");
+        // Enable persistent connections with an initial delay of 0.
+        this.tcpSocket.setKeepAlive(true, 0);
+        // Disable buffering of outgoing data.
+        this.tcpSocket.setNoDelay(true);
+        // Forward the encountered errors.
+        this.tcpSocket.on("error", this.eventForwarders.tcpError);
+    }
+    /**
+	 * Sets up forwarding of events related to the connection.
+	 *
+	 * @param {string} connectionType   Name of the connection/transport type, used for logging.
+	 * @param {string} host             Fully qualified domain name or IP address of the host
+	 * @param {number} port             Network port for the host to connect to
+	 */ onConnect(connectionType, host, port) {
+        // If the onConnect function has already run, do not execute it again.
+        if (this.onConnectHasRun) return;
+        // Log that the connection has been established.
+        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).network(`Established ${connectionType} connection with '${host}:${port}'.`);
+        // Forward the socket events
+        this.tcpSocket.addListener("close", this.eventForwarders.disconnect);
+        this.tcpSocket.addListener("data", this.eventForwarders.tcpData);
+        // Indicate that the onConnect function has run.
+        this.onConnectHasRun = true;
+        // Emit the connect event.
+        this.emit("connect");
+    }
+    /**
+	 * Clears the disconnect timer if it is still active.
+	 */ clearDisconnectTimerOnTimeout() {
+        // Clear the retry timer if it is still active.
+        if (this.timers.disconnect) clearTimeout(this.timers.disconnect);
+    }
+    /**
+	 * Forcibly terminate the connection.
+	 *
+	 * @throws {Error} if no connection was found
+	 */ disconnect() {
+        // Clear the disconnect timer so that the socket does not try to disconnect again later.
+        this.clearDisconnectTimerOnTimeout();
+        // Remove all event forwarders.
+        this.tcpSocket.removeListener("close", this.eventForwarders.disconnect);
+        this.tcpSocket.removeListener("data", this.eventForwarders.tcpData);
+        this.tcpSocket.removeListener("error", this.eventForwarders.tcpError);
+        // Terminate the connection.
+        this.tcpSocket.destroy();
+        // Remove the stored socket.
+        this.tcpSocket = undefined;
+        // Indicate that the onConnect function has not run and it has to be run again.
+        this.onConnectHasRun = false;
+        // Emit a disconnect event
+        this.emit("disconnect");
+    }
+    /**
+	 * Write data to the socket
+	 *
+	 * @param {Uint8Array | string} data   Data to be written to the socket
+	 * @param {function} callback          Callback function to be called when the write has completed
+	 *
+	 * @throws {Error} if no connection was found
+	 * @returns true if the message was fully flushed to the socket, false if part of the message
+	 * is queued in the user memory
+	 */ write(data, callback) {
+        // Throw an error if no active connection is found
+        if (!this.tcpSocket) throw new Error("Cannot write to socket when there is no active connection");
+        // Write data to the TLS Socket and return the status indicating
+        // whether the full message was flushed to the socket
+        return this.tcpSocket.write(data, callback);
+    }
+    /**
+	 * Force a disconnection if no connection is established after `timeout` milliseconds.
+	 *
+	 * @param {string} host      Host of the connection that timed out
+	 * @param {number} port      Port of the connection that timed out
+	 * @param {number} timeout   Elapsed milliseconds
+	 */ disconnectOnTimeout(host, port, timeout) {
+        // Remove the connect listener.
+        this.removeListener("connect", this.clearDisconnectTimerOnTimeout);
+        // Create a new timeout error.
+        const timeoutError = {
+            code: "ETIMEDOUT",
+            message: `Connection to '${host}:${port}' timed out after ${timeout} milliseconds`
+        };
+        // Emit an error event so that connect is rejected upstream.
+        this.emit("error", timeoutError);
+        // Forcibly disconnect to clean up the connection on timeout
+        this.disconnect();
+    }
+    constructor(...args){
+        super(...args);
+        // Declare timers for keep-alive pings and reconnection
+        this.timers = {};
+        // Initialize boolean that indicates whether the onConnect function has run (initialize to false).
+        this.onConnectHasRun = false;
+        // Initialize event forwarding functions.
+        this.eventForwarders = {
+            disconnect: ()=>this.emit("disconnect"),
+            tcpData: (data)=>this.emit("data", data),
+            tcpError: (err)=>this.emit("error", err)
+        };
+    }
+}
+class $ea64e414b68fe23b$export$25b4633f61498e1 extends (0, $4QiMX$EventEmitter) {
+    /**
+	 * Connect to host:port using the specified transport
+	 *
+	 * @param {string} host              Fully qualified domain name or IP address of the host
+	 * @param {number} port              Network port for the host to connect to
+	 * @param {TransportScheme} scheme   Transport scheme to use
+	 * @param {number} timeout           If no connection is established after `timeout` ms, the connection is terminated
+	 *
+	 * @throws {Error} if an incorrect transport scheme is specified
+	 */ connect(host, port, scheme, timeout) {
+        // Check that no existing socket exists before initiating a new connection.
+        if (this.webSocket) throw new Error("Cannot initiate a new socket connection when an existing connection exists");
+        // Set a timer to force disconnect after `timeout` seconds
+        this.timers.disconnect = setTimeout(()=>this.disconnectOnTimeout(host, port, timeout), timeout);
+        // Remove the timer if a connection is successfully established
+        this.once("connect", this.clearDisconnectTimerOnTimeout);
+        // Define how to refer to the connection scheme in debug output.
+        const socketTypes = {
             [(0, $5abc8fb342687c03$export$d048df559e6d3842).WS.Scheme]: "a WebSocket",
             [(0, $5abc8fb342687c03$export$d048df559e6d3842).WSS.Scheme]: "an encrypted WebSocket"
         };
         // Log that we are trying to establish a connection.
         (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).network(`Initiating ${socketTypes[scheme]} connection to '${host}:${port}'.`);
-        if (scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).TCP.Scheme || scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).TCP_TLS.Scheme) {
-            if (scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).TCP_TLS.Scheme) {
-                // Initialize connection options.
-                const connectionOptions = {
-                    rejectUnauthorized: false
-                };
-                // If the hostname is not an IP address..
-                if (!$4QiMX$isIP(host)) // Set the servername option which enables support for SNI.
-                // NOTE: SNI enables a server that hosts multiple domains to provide the appropriate TLS certificate.
-                connectionOptions.serverName = host;
-                // Initialize this.tcpSocket (allowing self-signed certificates).
-                this.tcpSocket = $4QiMX$connect(port, host, connectionOptions);
-                // Add a 'secureConnect' listener that checks the authorization status of
-                // the socket, and logs a warning when it uses a self signed certificate.
-                this.tcpSocket.once("secureConnect", ()=>{
-                    // Cannot happen, since this event callback *only* exists on TLSSocket
-                    if (!(this.tcpSocket instanceof $4QiMX$TLSSocket)) return;
-                    // Force cast authorizationError from Error to string (through unknown)
-                    // because it is incorrectly typed as an Error
-                    const authorizationError = this.tcpSocket.authorizationError;
-                    if (authorizationError === "DEPTH_ZERO_SELF_SIGNED_CERT") (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).warning(`Connection to ${host}:${port} uses a self-signed certificate`);
-                });
-                // Trigger successful connection events.
-                this.tcpSocket.on("secureConnect", this.onConnect.bind(this, socketTypes[scheme], host, port));
-            } else {
-                // Initialize this.tcpSocket.
-                this.tcpSocket = $4QiMX$connect1({
-                    host: host,
-                    port: port
-                });
-                // Trigger successful connection events.
-                this.tcpSocket.on("connect", this.onConnect.bind(this, socketTypes[scheme], host, port));
-            }
-            // Configure encoding.
-            this.tcpSocket.setEncoding("utf8");
-            // Enable persistent connections with an initial delay of 0.
-            this.tcpSocket.setKeepAlive(true, 0);
-            // Disable buffering of outgoing data.
-            this.tcpSocket.setNoDelay(true);
-            // Forward the encountered errors.
-            this.tcpSocket.on("error", this.eventForwarders.tcpError);
-        } else if (scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).WS.Scheme || scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).WSS.Scheme) {
-            if (scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).WSS.Scheme) // Initialize this.webSocket (rejecting self-signed certificates).
-            // We reject self-signed certificates to match functionality of browsers.
-            this.webSocket = new (0, $4QiMX$WebSocket)(`wss://${host}:${port}`);
-            else // Initialize this.webSocket.
-            this.webSocket = new (0, $4QiMX$WebSocket)(`ws://${host}:${port}`);
-            // Trigger successful connection events.
-            this.webSocket.addEventListener("open", this.onConnect.bind(this, socketTypes[scheme], host, port));
-            // Forward the encountered errors.
-            this.webSocket.addEventListener("error", this.eventForwarders.wsError);
-        } else // Throw an error if an incorrect transport is specified
+        if (scheme !== (0, $5abc8fb342687c03$export$d048df559e6d3842).WS.Scheme && scheme !== (0, $5abc8fb342687c03$export$d048df559e6d3842).WSS.Scheme) // Throw an error if an incorrect transport is specified
         throw new Error("Incorrect transport specified");
+        if (scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).WSS.Scheme) // Initialize this.webSocket (rejecting self-signed certificates).
+        // We reject self-signed certificates to match functionality of browsers.
+        this.webSocket = new (0, $4QiMX$WebSocket)(`wss://${host}:${port}`);
+        else // Initialize this.webSocket.
+        this.webSocket = new (0, $4QiMX$WebSocket)(`ws://${host}:${port}`);
+        // Trigger successful connection events.
+        this.webSocket.addEventListener("open", this.onConnect.bind(this, socketTypes[scheme], host, port));
+        // Forward the encountered errors.
+        this.webSocket.addEventListener("error", this.eventForwarders.wsError);
     }
     /**
 	 * Sets up forwarding of events related to the connection.
@@ -282,15 +390,9 @@ const $5abc8fb342687c03$export$f019be48b3aacb1a = {
         if (this.onConnectHasRun) return;
         // Log that the connection has been established.
         (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).network(`Established ${connectionType} connection with '${host}:${port}'.`);
-        if (typeof this.tcpSocket !== "undefined") {
-            // Forward the socket events
-            this.tcpSocket.addListener("close", this.eventForwarders.disconnect);
-            this.tcpSocket.addListener("data", this.eventForwarders.tcpData);
-        } else if (typeof this.webSocket !== "undefined") {
-            // Forward the socket events
-            this.webSocket.addEventListener("close", this.eventForwarders.disconnect);
-            this.webSocket.addEventListener("message", this.eventForwarders.wsData);
-        }
+        // Forward the socket events
+        this.webSocket.addEventListener("close", this.eventForwarders.disconnect);
+        this.webSocket.addEventListener("message", this.eventForwarders.wsData);
         // Indicate that the onConnect function has run.
         this.onConnectHasRun = true;
         // Emit the connect event.
@@ -309,17 +411,7 @@ const $5abc8fb342687c03$export$f019be48b3aacb1a = {
 	 */ disconnect() {
         // Clear the disconnect timer so that the socket does not try to disconnect again later.
         this.clearDisconnectTimerOnTimeout();
-        // Handle disconnect based differently depending on socket type.
-        if (this.tcpSocket) {
-            // Remove all event forwarders.
-            this.tcpSocket.removeListener("close", this.eventForwarders.disconnect);
-            this.tcpSocket.removeListener("data", this.eventForwarders.tcpData);
-            this.tcpSocket.removeListener("error", this.eventForwarders.tcpError);
-            // Terminate the connection.
-            this.tcpSocket.destroy();
-            // Remove the stored socket.
-            this.tcpSocket = undefined;
-        } else if (this.webSocket) try {
+        try {
             // Remove all event forwarders.
             this.webSocket.removeEventListener("close", this.eventForwarders.disconnect);
             this.webSocket.removeEventListener("message", this.eventForwarders.wsData);
@@ -348,17 +440,12 @@ const $5abc8fb342687c03$export$f019be48b3aacb1a = {
 	 * @returns true if the message was fully flushed to the socket, false if part of the message
 	 * is queued in the user memory
 	 */ write(data, callback) {
-        if (this.tcpSocket) // Write data to the TLS Socket and return the status indicating whether the
-        // full message was flushed to the socket
-        return this.tcpSocket.write(data, callback);
-        if (this.webSocket) {
-            // Write data to the WebSocket
-            this.webSocket.send(data, callback);
-            // WebSockets always fit everything in a single request, so we return true
-            return true;
-        }
         // Throw an error if no active connection is found
-        throw new Error("Cannot write to socket when there is no active connection");
+        if (!this.webSocket) throw new Error("Cannot write to socket when there is no active connection");
+        // Write data to the WebSocket
+        this.webSocket.send(data, callback);
+        // WebSockets always fit everything in a single request, so we return true
+        return true;
     }
     /**
 	 * Force a disconnection if no connection is established after `timeout` milliseconds.
@@ -388,15 +475,11 @@ const $5abc8fb342687c03$export$f019be48b3aacb1a = {
         // Initialize event forwarding functions.
         this.eventForwarders = {
             disconnect: ()=>this.emit("disconnect"),
-            tcpData: (data)=>this.emit("data", data),
             wsData: (event)=>this.emit("data", `${event.data}\n`),
-            tcpError: (err)=>this.emit("error", err),
             wsError: (event)=>this.emit("error", event.error)
         };
     }
 }
-var // export the socket.
-$ea64e414b68fe23b$export$2e2bcd8739ae039 = $ea64e414b68fe23b$var$ElectrumSocket;
 
 
 
@@ -432,15 +515,10 @@ $ea64e414b68fe23b$export$2e2bcd8739ae039 = $ea64e414b68fe23b$var$ElectrumSocket;
         this.pingInterval = pingInterval;
         this.reconnectInterval = reconnectInterval;
         this.useBigInt = useBigInt;
-        this.// Declare timers for keep-alive pings and reconnection
-        timers = {};
-        this.// Initialize an empty array of connection verification timers.
-        // eslint-disable-next-line no-undef
-        verifications = [];
-        this.// Initialize the connected flag to false to indicate that there is no connection
-        status = (0, $a58372b18a18806e$export$7516420eb880ab68).DISCONNECTED;
-        this.// Initialize messageBuffer to an empty string
-        messageBuffer = "";
+        this.status = (0, $a58372b18a18806e$export$7516420eb880ab68).DISCONNECTED;
+        this.timers = {};
+        this.verifications = [];
+        this.messageBuffer = "";
         // Check if the provided version is a valid version number.
         if (!(0, $c78f59d21170b7a6$export$2e2bcd8739ae039).versionRegexp.test(version)) // Throw an error since the version number was not valid.
         throw new Error(`Provided version string (${version}) is not a valid protocol version number.`);
@@ -457,8 +535,12 @@ $ea64e414b68fe23b$export$2e2bcd8739ae039 = $ea64e414b68fe23b$var$ElectrumSocket;
     /**
 	 * Create and configures a fresh socket and attaches all relevant listeners.
 	 */ createSocket() {
-        // Initialize a new ElectrumSocket
-        this.socket = new (0, $ea64e414b68fe23b$export$2e2bcd8739ae039)();
+        if (this.scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).TCP.Scheme || this.scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).TCP_TLS.Scheme) // Initialize a new ElectrumTcpSocket
+        this.socket = new (0, $ea64e414b68fe23b$export$22c0ca2c816c3e08)();
+        else if (this.scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).WS.Scheme || this.scheme === (0, $5abc8fb342687c03$export$d048df559e6d3842).WSS.Scheme) // Initialize a new ElectrumWebSocket
+        this.socket = new (0, $ea64e414b68fe23b$export$25b4633f61498e1)();
+        else // Throw an error if an incorrect transport is specified
+        throw new Error(`Provided transport (${this.scheme}) is not a valid ElectrumTransport`);
         // Set up handlers for connection and disconnection.
         this.socket.on("connect", this.onSocketConnect.bind(this));
         this.socket.on("disconnect", this.onSocketDisconnect.bind(this));
@@ -882,13 +964,18 @@ const $7c0fb93e8eea922a$export$94e3360fcddccc76 = function(message) {
 	 */ constructor(application, version, host, port = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).PORT, scheme = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).TRANSPORT_SCHEME, timeout = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).TIMEOUT, pingInterval = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).PING_INTERVAL, reconnectInterval = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).RECONNECT, useBigInt = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).USE_BIG_INT){
         // Initialize the event emitter.
         super();
-        // Initialize an empty list of subscription metadata.
+        this.application = application;
+        this.version = version;
+        this.host = host;
+        this.port = port;
+        this.scheme = scheme;
+        this.timeout = timeout;
+        this.pingInterval = pingInterval;
+        this.reconnectInterval = reconnectInterval;
+        this.useBigInt = useBigInt;
         this.subscriptionMethods = {};
-        // Start counting the request IDs from 0
         this.requestId = 0;
-        // Initialize an empty dictionary for keeping track of request resolvers
         this.requestResolvers = {};
-        // Mutex lock used to prevent simultaneous connect() and disconnect() calls.
         this.connectionLock = new (0, $4QiMX$Mutex)();
         // Set up a connection to an electrum server.
         this.connection = new (0, $1326c18f93f95fee$export$2e2bcd8739ae039)(application, version, host, port, scheme, timeout, pingInterval, reconnectInterval, useBigInt);
@@ -1134,484 +1221,5 @@ $620a18299ef8d6fd$export$2e2bcd8739ae039 = $620a18299ef8d6fd$var$ElectrumClient;
 
 
 
-
-
-/**
- * Triggers when the cluster connects to enough servers to satisfy both the cluster confidence and distribution policies.
- *
- * @event ElectrumCluster#ready
- * @deprecated
- */ /**
- * Triggers when the cluster loses a connection and can no longer satisfy the cluster distribution policy.
- *
- * @event ElectrumCluster#degraded
- * @deprecated
- */ /**
- * Triggers when the cluster loses a connection and can no longer satisfy the cluster confidence policy.
- *
- * @event ElectrumCluster#disabled
- * @deprecated
- */ /**
- * Triggers when the cluster verifies the integrity of remote server sent data that is not a request responses.
- *
- * @event ElectrumCluster#notification
- * @deprecated
- */ /**
- * High-level electrum client that provides transparent load balancing, confidence checking and/or low-latency polling.
- * @deprecated
- */ class $9b2ed2eb52532075$var$ElectrumCluster extends (0, $4QiMX$EventEmitter) {
-    /**
-	 * @param {string} application    your application name, used to identify to the electrum hosts.
-	 * @param {string} version        protocol version to use with the hosts.
-	 * @param {number} confidence     wait for this number of hosts to provide identical results.
-	 * @param {number} distribution   request information from this number of hosts.
-	 * @param {ClusterOrder} order    select hosts to communicate with in this order.
-	 * @param {number} timeout        how long network delays we will wait for before taking action, in milliseconds.
-	 * @param {number} pingInterval      the time between sending pings to the electrum host, in milliseconds.
-	 * @param {number} reconnectInterval the time between reconnection attempts to the electrum host, in milliseconds.
-	 * @param {boolean} useBigInt	  whether to use bigint for numbers in json response.
-	 */ constructor(application, version, confidence = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).CLUSTER_CONFIDENCE, distribution = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).CLUSTER_DISTRIBUTION, order = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).CLUSTER_ORDER, timeout = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).TIMEOUT, pingInterval = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).PING_INTERVAL, reconnectInterval = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).RECONNECT, useBigInt = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).USE_BIG_INT){
-        // Initialize the event emitter.
-        super();
-        this.application = application;
-        this.version = version;
-        this.confidence = confidence;
-        this.distribution = distribution;
-        this.order = order;
-        this.timeout = timeout;
-        this.pingInterval = pingInterval;
-        this.reconnectInterval = reconnectInterval;
-        this.useBigInt = useBigInt;
-        this.// Initialize an empty dictionary of clients in the cluster
-        clients = {};
-        this.// Start at 0 connected clients
-        connections = 0;
-        this.// Set up an empty set of notification data.
-        notifications = {};
-        this.// Start the cluster in DISABLED state
-        status = (0, $a58372b18a18806e$export$c66b56bc0ff967ca).DISABLED;
-        this.// Start counting request IDs at 0
-        requestCounter = 0;
-        this.// Initialize an empty dictionary for keeping track of request resolvers
-        requestPromises = {};
-        this.// Lock to prevent concurrency race conditions when sending requests.
-        requestLock = new (0, $4QiMX$Mutex)();
-        this.// Lock to prevent concurrency race conditions when receiving responses.
-        responseLock = new (0, $4QiMX$Mutex)();
-        // Write a log message.
-        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).cluster(`Initialized empty cluster (${confidence} of ${distribution || "ALL"})`);
-        // Print out a warning if we cannot guarantee consensus for subscription notifications.
-        // Case 1: we don't know how many servers will be used, so warning just to be safe
-        // Case 2: we know the number of servers needed to trust a response is less than 50%.
-        if (distribution === (0, $a58372b18a18806e$export$436a960acc41e848).ALL || confidence / distribution <= 0.50) (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).warning(`Subscriptions might return multiple valid responses when confidence (${confidence}) is less than 51% of distribution.`);
-    }
-    /**
-	 * Adds a server to the cluster.
-	 * @deprecated
-	 *
-	 * @param {string} host              fully qualified domain name or IP number of the host.
-	 * @param {number} port              the TCP network port of the host.
-	 * @param {TransportScheme} scheme   the transport scheme to use for connection
-	 * @param {boolean} autoConnect      flag indicating whether the server should automatically connect (default true)
-	 *
-	 * @throws {Error} if the cluster's version is not a valid version string.
-	 * @returns a promise that resolves when the connection has been initiated.
-	 */ async addServer(host, port = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).PORT, scheme = (0, $5abc8fb342687c03$export$f019be48b3aacb1a).TRANSPORT_SCHEME, autoConnect = true) {
-        // Set up a new electrum client.
-        const client = new (0, $620a18299ef8d6fd$export$2e2bcd8739ae039)(this.application, this.version, host, port, scheme, this.timeout, this.pingInterval, this.reconnectInterval, this.useBigInt);
-        // Define the client identity to avoid repetition.
-        const clientIdentity = `${host}:${port}`;
-        // Store this client.
-        this.clients[clientIdentity] = {
-            state: (0, $a58372b18a18806e$export$c4f81c6d30ca200f).UNAVAILABLE,
-            connection: client
-        };
-        /**
-		 * Define a helper function to evaluate and log cluster status.
-		 *
-		 * @fires ElectrumCluster#ready
-		 * @fires ElectrumCluster#degraded
-		 * @fires ElectrumCluster#disabled
-		 */ const updateClusterStatus = ()=>{
-            // Calculate the required distribution, taking into account that distribution to all is represented with 0.
-            const distribution = Math.max(this.confidence, this.distribution);
-            // Check if we have enough connections to saturate distribution.
-            if (this.connections >= distribution) // If the cluster is not currently considered ready..
-            {
-                if (this.status !== (0, $a58372b18a18806e$export$c66b56bc0ff967ca).READY) {
-                    // Mark the cluster as ready.
-                    this.status = (0, $a58372b18a18806e$export$c66b56bc0ff967ca).READY;
-                    // Emit the ready signal to indicate the cluster is running in a ready mode.
-                    this.emit("ready");
-                    // Write a log message with an update on the current cluster status.
-                    (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).cluster(`Cluster status is ready (currently ${this.connections} of ${distribution} connections available.)`);
-                }
-            } else if (this.connections >= this.confidence) // If the cluster is not currently considered degraded..
-            {
-                if (this.status !== (0, $a58372b18a18806e$export$c66b56bc0ff967ca).DEGRADED) {
-                    // Mark the cluster as degraded.
-                    this.status = (0, $a58372b18a18806e$export$c66b56bc0ff967ca).DEGRADED;
-                    // Emit the degraded signal to indicate the cluster is running in a degraded mode.
-                    this.emit("degraded");
-                    // Write a log message with an update on the current cluster status.
-                    (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).cluster(`Cluster status is degraded (only ${this.connections} of ${distribution} connections available.)`);
-                }
-            } else if (this.status !== (0, $a58372b18a18806e$export$c66b56bc0ff967ca).DISABLED) {
-                // Mark the cluster as disabled.
-                this.status = (0, $a58372b18a18806e$export$c66b56bc0ff967ca).DISABLED;
-                // Emit the degraded signal to indicate the cluster is disabled.
-                this.emit("disabled");
-                // Write a log message with an update on the current cluster status.
-                (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).cluster(`Cluster status is disabled (only ${this.connections} of the ${distribution} connections are available.)`);
-            }
-        };
-        // Define a function to run when client has connected.
-        const onConnect = async ()=>{
-            // Wrap in a try-catch so we can ignore errors.
-            try {
-                // Check connection status
-                const connectionStatus = client.connection.status;
-                // If the connection is fine..
-                if (connectionStatus === (0, $a58372b18a18806e$export$7516420eb880ab68).CONNECTED) {
-                    // If this was from an unavailable connection..
-                    if (this.clients[clientIdentity].state === (0, $a58372b18a18806e$export$c4f81c6d30ca200f).UNAVAILABLE) // Update connection counter.
-                    this.connections += 1;
-                    // Set client state to available.
-                    this.clients[clientIdentity].state = (0, $a58372b18a18806e$export$c4f81c6d30ca200f).AVAILABLE;
-                    // update the cluster status.
-                    updateClusterStatus();
-                }
-            } catch (error) {
-            // Do nothing.
-            }
-        };
-        // Define a function to run when client disconnects.
-        const onDisconnect = ()=>{
-            // If this was from an established connection..
-            if (this.clients[clientIdentity].state === (0, $a58372b18a18806e$export$c4f81c6d30ca200f).AVAILABLE) // Update connection counter.
-            this.connections -= 1;
-            // Set client state to unavailable.
-            this.clients[clientIdentity].state = (0, $a58372b18a18806e$export$c4f81c6d30ca200f).UNAVAILABLE;
-            // update the cluster status.
-            updateClusterStatus();
-        };
-        // Set up handlers for connection and disconnection.
-        client.connection.on("connect", onConnect.bind(this));
-        client.connection.on("disconnect", onDisconnect.bind(this));
-        // Set up handler for notification events, that includes the identity of this client so it can be tracked.
-        client.on("notification", this.handleSubscriptionNotifications.bind(this, clientIdentity));
-        // Connect if auto-connect is set to true, returning the connection result.
-        if (autoConnect) try {
-            // Set up the connection.
-            await client.connect();
-        } catch (error) {
-            // Log a message why the connection failed and move on.
-            (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).cluster(`Failed to connect with ${host}: ${error}`);
-        }
-    }
-    /**
-	 * Calls a method on the remote server with the supplied parameters.
-	 * @deprecated
-	 *
-	 * @param {string}    method       name of the method to call.
-	 * @param {...string} parameters   one or more parameters for the method.
-	 *
-	 * @throws {Error} if not enough clients are connected
-	 * @throws {Error} if no response is received with sufficient integrity
-	 * @returns a promise that resolves with the result of the method.
-	 */ async request(method, ...parameters) {
-        // Check if the cluster is unable to serve requests.
-        if (this.status === (0, $a58372b18a18806e$export$c66b56bc0ff967ca).DISABLED) throw new Error(`Cannot request '${method}' when available clients (${this.connections}) is less than required confidence (${this.confidence}).`);
-        // Lock this request method temporarily.
-        const unlock = await this.requestLock.acquire();
-        // Declare requestId outside of try-catch scope.
-        let requestId = 0;
-        // NOTE: If this async method is called very rapidly, it's theoretically possible that the parts below could interfere.
-        try {
-            // Increase the current request counter.
-            this.requestCounter += 1;
-            // Copy the request counter so we can work with the copy and know it won't change
-            // even if the request counter is raised from concurrent requests.
-            requestId = this.requestCounter;
-        } finally{
-            // Unlock this request method now that the concurrency sensitive condition is completed.
-            unlock();
-        }
-        // Initialize an empty list of request promises.
-        this.requestPromises[requestId] = [];
-        // Extract all available client IDs
-        const availableClientIDs = Object.keys(this.clients).filter((clientID)=>this.clients[clientID].state === (0, $a58372b18a18806e$export$c4f81c6d30ca200f).AVAILABLE);
-        // Initialize a sent counter.
-        let sentCounter = 0;
-        // Determine the number of clients we need to send to, taking ClusterDistribution.ALL (=0) into account.
-        let requiredDistribution = this.distribution || availableClientIDs.length;
-        // If the cluster is in degraded status, we do not have enough available clients to
-        // match distribution, but still enough to reach consensus, so we use the clients we have.
-        if (this.status === (0, $a58372b18a18806e$export$c66b56bc0ff967ca).DEGRADED) requiredDistribution = availableClientIDs.length;
-        // Repeat until we have sent the request to the desired number of clients.
-        while(sentCounter < requiredDistribution){
-            // Pick an array index according to our ordering strategy.
-            let currentIndex = 0;
-            // Use a random array index when cluster order is set to RANDOM
-            if (this.order === (0, $a58372b18a18806e$export$161fe3707f756bf9).RANDOM) currentIndex = Math.floor(Math.random() * availableClientIDs.length);
-            // Move a client identity from the client list to its own variable.
-            const [currentClient] = availableClientIDs.splice(currentIndex, 1);
-            // Send the request to the client and store the request promise.
-            const requestPromise = this.clients[currentClient].connection.request(method, ...parameters);
-            this.requestPromises[requestId].push(requestPromise);
-            // Increase the sent counter.
-            sentCounter += 1;
-        }
-        // Define a function to poll for request responses.
-        const pollResponse = (resolve, reject)=>{
-            // Define a function to resolve request responses based on integrity.
-            const resolveRequest = async ()=>{
-                // Set up an empty set of response data.
-                const responseData = {};
-                // Set up a counter to keep track of how many responses we have checked.
-                let checkedResponses = 0;
-                // For each server we issued a request to..
-                for(const currentPromise in this.requestPromises[requestId]){
-                    // Initialize a holder for the response in the required scope to use it.
-                    let response;
-                    // Race the request promise against a pre-resolved request to determine request status.
-                    try {
-                        // Arrange an array of the current promise and an empty promise such that..
-                        const promises = [
-                            this.requestPromises[requestId][currentPromise],
-                            Promise.resolve(undefined)
-                        ];
-                        // .. we can get the result of the current promise if it is currently resolved, but don't need to wait for it otherwise.
-                        response = await Promise.race(promises);
-                    } // Handle case where the request sent resulted in a thrown error / promise rejection, rather then resolving to a response.
-                    // Note that in the worst time case, each request can be expected to  eventually throw an error on timeout.
-                    catch (error) {
-                        // Increase the counter for checked responses.
-                        checkedResponses += 1;
-                        continue;
-                    }
-                    // If the promise is settled..
-                    if (response !== undefined) {
-                        // Calculate a unique identifier for this notification data.
-                        const responseDataIdentifier = (0, $4QiMX$stringify)(response);
-                        // Increase the counter for checked responses.
-                        checkedResponses += 1;
-                        // Either set the response data counter or increase it.
-                        if (responseData[responseDataIdentifier] === undefined) responseData[responseDataIdentifier] = 1;
-                        else responseData[responseDataIdentifier] += 1;
-                        // Check if this response has enough integrity according to our confidence strategy.
-                        if (responseData[responseDataIdentifier] === this.confidence) {
-                            // Write log entry.
-                            (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).cluster(`Validated response for '${method}' with sufficient integrity (${this.confidence}).`);
-                            // Resolve the request with this response.
-                            resolve(response);
-                            // Return after resolving since we do not want to continue the execution.
-                            return;
-                        }
-                    }
-                }
-                // If all clients have responded but we failed to reach desired integrity..
-                if (checkedResponses === this.requestPromises[requestId].length) {
-                    // Reject this request with an error message.
-                    reject(new Error(`Unable to complete request for '${method}', response failed to reach sufficient integrity (${this.confidence}).`));
-                    // Return after rejecting since we do not want to continue the execution.
-                    return;
-                }
-                // If we are not ready, but have not timed out and should wait more..
-                setTimeout(resolveRequest, 1000);
-            };
-            // Attempt the initial resolution of the request.
-            resolveRequest();
-        };
-        // return some kind of promise that resolves when integrity number of clients results match.
-        return new Promise(pollResponse);
-    }
-    /**
-	 * Subscribes to the method at the cluster and attaches the callback function to the event feed.
-	 * @deprecated
-	 *
-	 * @note the response for the subscription request is issued as a notification event.
-	 *
-	 * @param {string}    method       one of the subscribable methods the server supports.
-	 * @param {...string} parameters   one or more parameters for the method.
-	 *
-	 * @throws {Error} if not enough clients are connected
-	 * @throws {Error} if no response is received with sufficient integrity for the initial request
-	 */ async subscribe(method, ...parameters) {
-        // Set up event listener for this subscription.
-        for(const currentClient in this.clients){
-            // Copy the current client for brevity.
-            const client = this.clients[currentClient].connection;
-            try {
-                // Send initial subscription request.
-                // NOTE: This stores and manages the subscription even if the initial request fails.
-                await client.subscribe(method, ...parameters);
-            } catch (error) {
-            // Do nothing, as this is handled on a best-effort basis and
-            // not all servers are expected to be ready at all times.
-            }
-        }
-    }
-    /**
-	 * Unsubscribes to the method at the cluster and removes any callback functions
-	 * when there are no more subscriptions for the method.
-	 * @deprecated
-	 *
-	 * @param {string}    method       one of the subscribable methods the server supports.
-	 * @param {...string} parameters   one or more parameters for the method.
-	 *
-	 * @throws {Error} if, for any of the clients, no subscriptions exist for the combination of the provided `method` and `parameters.
-	 */ async unsubscribe(method, ...parameters) {
-        // Initialize an empty list to track subscription requests.
-        const unsubscriptionPromises = [];
-        // For each client..
-        for(const currentClient in this.clients){
-            // Store client in variable for brevity
-            const client = this.clients[currentClient].connection;
-            // unsubscribe this client.
-            unsubscriptionPromises.push(client.unsubscribe(method, ...parameters));
-        }
-        // Wait for all unsubscription promises to resolve.
-        await Promise.all(unsubscriptionPromises);
-    }
-    /**
-	 * Define a callback function to validate server notifications and pass them to the subscribe callback.
-	 * @deprecated
-	 *
-	 * @ignore
-	 */ async handleSubscriptionNotifications(clientIdentity, data) {
-        // Lock this response method temporarily.
-        const unlock = await this.responseLock.acquire();
-        try {
-            // Calculate a unique identifier for this notification data.
-            const responseDataIdentifier = (0, $4QiMX$stringify)(data);
-            // Create an empty list of clients who have responded to this notification, if necessary.
-            if (this.notifications[responseDataIdentifier] === undefined) this.notifications[responseDataIdentifier] = new Set();
-            // Ensure this client is on the list of clients that have provided this specific notification.
-            this.notifications[responseDataIdentifier].add(clientIdentity);
-            // Check if this notification has enough integrity according to our confidence strategy.
-            // NOTE: We check against === instead of >== in order to ensure that we only emit each notification once.
-            if (this.notifications[responseDataIdentifier].size === this.confidence) {
-                // Write log entry.
-                (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).cluster(`Validated notification for '${data.method}' with sufficient integrity (${this.confidence}).`);
-                // Emit an event for the notification data.
-                this.emit("notification", data);
-                // Dismiss the notification data after all nodes are assumed to have sent their notifications.
-                // NOTE: This is a redundant mechanic to ensure that even if some nodes don't provide this notification, we still clear this data.
-                // NOTE: This also introduces a race-condition where if a legit identical notification comes in before/during this timeout, it might get silenced.
-                setTimeout(this.dismissSubscriptionNotification.bind(this, responseDataIdentifier), this.timeout);
-            }
-            // Check if this notification has been fully handled.
-            if (this.notifications[responseDataIdentifier].size === this.distribution) // Dismiss existing response data as we know all related parties have provided their input.
-            this.dismissSubscriptionNotification(responseDataIdentifier);
-        } finally{
-            // Unlock the response method so it can handle the next set of data.
-            unlock();
-        }
-    }
-    /**
-	 * Forgets/Removes notification data for a specific notification.
-	 *
-	 * This is required in order to allow future identical notifications to be properly processed and emitted.
-	 * @deprecated
-	 */ async dismissSubscriptionNotification(responseDataIdentifier) {
-        delete this.notifications[responseDataIdentifier];
-    }
-    /**
-	 * Provides a method to check or wait for the cluster to become ready.
-	 * @deprecated
-	 *
-	 * @returns a promise that resolves when the required servers are available.
-	 */ async ready() {
-        // Store the current timestamp.
-        const readyTimestamp = Date.now();
-        // Define a function to poll for availability of the cluster.
-        const availabilityPoller = (resolve)=>{
-            // Define a function to check if the cluster is ready to be used.
-            const connectionAvailabilityVerifier = ()=>{
-                // Check if the cluster is active..
-                if (this.status === (0, $a58372b18a18806e$export$c66b56bc0ff967ca).READY) {
-                    // Resolve with true to indicate that the cluster is ready to use.
-                    resolve(true);
-                    // Return after resolving since we do not want to continue the execution.
-                    return;
-                }
-                // Calculate how long we have waited, in milliseconds.
-                const timeWaited = Date.now() - readyTimestamp;
-                // Check if we have waited longer than our timeout setting.
-                if (timeWaited > this.timeout) {
-                    // Resolve with false to indicate that we did not get ready in time.
-                    resolve(false);
-                    // Return after resolving since we do not want to continue the execution.
-                    return;
-                }
-                // If we are not ready, but have not timed out and should wait more..
-                setTimeout(connectionAvailabilityVerifier, 50);
-            };
-            // Run the initial verification.
-            connectionAvailabilityVerifier();
-        };
-        // Return a promise that resolves when the available clients is sufficient.
-        return new Promise(availabilityPoller);
-    }
-    /**
-	 * Connects all servers from the cluster and attaches event listeners and handlers
-	 * for all underlying clients and connections.
-	 * @deprecated
-	 *
-	 * @throws {Error} if the cluster's version is not a valid version string.
-	 */ async startup() {
-        // Write a log message.
-        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).cluster("Starting up cluster.");
-        // Keep track of all connections
-        const connections = [];
-        // Loop over all clients and reconnect them if they're disconnected
-        for(const clientKey in this.clients){
-            // Retrieve connection information for the client
-            const { host: host, port: port, scheme: scheme } = this.clients[clientKey].connection.connection;
-            // Only connect currently unavailable/disconnected clients
-            if (this.clients[clientKey].state === (0, $a58372b18a18806e$export$c4f81c6d30ca200f).AVAILABLE) // Warn when a server is already connected when calling startup()
-            (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).warning(`Called startup(), but server ${host}:${port} is already connected`);
-            else // Call the addServer() function with the existing connection data
-            // This effectively reconnects the server and re-instates all event listeners
-            connections.push(this.addServer(host, port, scheme));
-        }
-        // Await all connections
-        return Promise.all(connections);
-    }
-    /**
-	 * Disconnects all servers from the cluster. Removes all event listeners and
-	 * handlers from all underlying clients and connections. This includes all
-	 * active subscriptions, unless retainSubscriptions is set to true.
-	 * @deprecated
-	 *
-	 * @param {boolean} retainSubscriptions   retain subscription data so they will be restored on reconnection.
-	 *
-	 * @returns a list with the disconnection result for every client
-	 */ async shutdown(retainSubscriptions = false) {
-        // Write a log message.
-        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).cluster("Shutting down cluster.");
-        // Set up a list of disconnections to wait for.
-        const disconnections = [];
-        const disconnectResolver = (resolve)=>{
-            // Resolve once the cluster is marked as disabled
-            this.once("disabled", ()=>resolve(Promise.all(disconnections)));
-            // For each client in this cluster..
-            for(const clientIndex in this.clients)// Force disconnection regardless of current status.
-            disconnections.push(this.clients[clientIndex].connection.disconnect(true, retainSubscriptions));
-        };
-        // Return a list of booleans indicating disconnections from all clients
-        return new Promise(disconnectResolver);
-    }
-}
-var // Export the cluster.
-$9b2ed2eb52532075$export$2e2bcd8739ae039 = $9b2ed2eb52532075$var$ElectrumCluster;
-
-
-
-
-
-
-
-export {$620a18299ef8d6fd$export$2e2bcd8739ae039 as ElectrumClient, $9b2ed2eb52532075$export$2e2bcd8739ae039 as ElectrumCluster, $a192ea5a4eec42d4$export$e1f38ab2b4ebdde6 as isVersionRejected, $a192ea5a4eec42d4$export$9598f0c76aa41d73 as isVersionNegotiated, $5abc8fb342687c03$export$d048df559e6d3842 as ElectrumTransport, $5abc8fb342687c03$export$f019be48b3aacb1a as DefaultParameters, $a58372b18a18806e$export$161fe3707f756bf9 as ClusterOrder, $a58372b18a18806e$export$436a960acc41e848 as ClusterDistribution, $a58372b18a18806e$export$c66b56bc0ff967ca as ClusterStatus, $a58372b18a18806e$export$c4f81c6d30ca200f as ClientState, $a58372b18a18806e$export$7516420eb880ab68 as ConnectionStatus};
+export {$620a18299ef8d6fd$export$2e2bcd8739ae039 as ElectrumClient, $a192ea5a4eec42d4$export$e1f38ab2b4ebdde6 as isVersionRejected, $a192ea5a4eec42d4$export$9598f0c76aa41d73 as isVersionNegotiated, $5abc8fb342687c03$export$d048df559e6d3842 as ElectrumTransport, $5abc8fb342687c03$export$f019be48b3aacb1a as DefaultParameters, $a58372b18a18806e$export$161fe3707f756bf9 as ClusterOrder, $a58372b18a18806e$export$436a960acc41e848 as ClusterDistribution, $a58372b18a18806e$export$c66b56bc0ff967ca as ClusterStatus, $a58372b18a18806e$export$c4f81c6d30ca200f as ClientState, $a58372b18a18806e$export$7516420eb880ab68 as ConnectionStatus};
 //# sourceMappingURL=index.mjs.map