@electrum-cash/network 3.2.0-r1 → 3.3.0-development.6103536979

package/dist/index.mjs

@@ -0,0 +1,1611 @@
+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 {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";
+
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
+// Create the debug logs.
+const $ef5ba40c8abe5a13$var$debug = {
+    client: (0, $4QiMX$debug)("electrum-cash:client "),
+    cluster: (0, $4QiMX$debug)("electrum-cash:cluster"),
+    errors: (0, $4QiMX$debug)("electrum-cash:error  "),
+    warning: (0, $4QiMX$debug)("electrum-cash:warning"),
+    network: (0, $4QiMX$debug)("electrum-cash:network"),
+    ping: (0, $4QiMX$debug)("electrum-cash:pulses ")
+};
+// Set log colors.
+$ef5ba40c8abe5a13$var$debug.client.color = "2";
+$ef5ba40c8abe5a13$var$debug.cluster.color = "3";
+$ef5ba40c8abe5a13$var$debug.errors.color = "9";
+$ef5ba40c8abe5a13$var$debug.warning.color = "13";
+$ef5ba40c8abe5a13$var$debug.network.color = "4";
+$ef5ba40c8abe5a13$var$debug.ping.color = "8";
+var // Export the logs.
+$ef5ba40c8abe5a13$export$2e2bcd8739ae039 = $ef5ba40c8abe5a13$var$debug;
+
+
+
+/**
+ * Grouping of utilities that simplifies implementation of the Electrum protocol.
+ *
+ * @ignore
+ */ class $c78f59d21170b7a6$var$ElectrumProtocol {
+    /**
+	 * Helper function that builds an Electrum request object.
+	 *
+	 * @param {string} method       method to call.
+	 * @param {array}  parameters   method parameters for the call.
+	 * @param {string} requestId    unique string or number referencing this request.
+	 *
+	 * @returns a properly formatted Electrum request string.
+	 */ static buildRequestObject(method, parameters, requestId) {
+        // Return the formatted request object.
+        // NOTE: Electrum either uses JsonRPC strictly or loosely.
+        //       If we specify protocol identifier without being 100% compliant, we risk being disconnected/blacklisted.
+        //       For this reason, we omit the protocol identifier to avoid issues.
+        return JSON.stringify({
+            method: method,
+            params: parameters,
+            id: requestId
+        });
+    }
+    /**
+	 * Constant used to verify if a provided string is a valid version number.
+	 *
+	 * @returns a regular expression that matches valid version numbers.
+	 */ static get versionRegexp() {
+        return /^\d+(\.\d+)+$/;
+    }
+    /**
+	 * Constant used to separate statements/messages in a stream of data.
+	 *
+	 * @returns the delimiter used by Electrum to separate statements.
+	 */ static get statementDelimiter() {
+        return "\n";
+    }
+}
+var // export the protocol.
+$c78f59d21170b7a6$export$2e2bcd8739ae039 = $c78f59d21170b7a6$var$ElectrumProtocol;
+
+
+var $a192ea5a4eec42d4$exports = {};
+
+$parcel$export($a192ea5a4eec42d4$exports, "isVersionRejected", () => $a192ea5a4eec42d4$export$e1f38ab2b4ebdde6);
+$parcel$export($a192ea5a4eec42d4$exports, "isVersionNegotiated", () => $a192ea5a4eec42d4$export$9598f0c76aa41d73);
+const $a192ea5a4eec42d4$export$e1f38ab2b4ebdde6 = function(object) {
+    return "error" in object;
+};
+const $a192ea5a4eec42d4$export$9598f0c76aa41d73 = function(object) {
+    return "software" in object && "protocol" in object;
+};
+
+
+var $5abc8fb342687c03$exports = {};
+
+$parcel$export($5abc8fb342687c03$exports, "ElectrumTransport", () => $5abc8fb342687c03$export$d048df559e6d3842);
+$parcel$export($5abc8fb342687c03$exports, "DefaultParameters", () => $5abc8fb342687c03$export$f019be48b3aacb1a);
+var $a58372b18a18806e$exports = {};
+
+$parcel$export($a58372b18a18806e$exports, "ClusterOrder", () => $a58372b18a18806e$export$161fe3707f756bf9);
+$parcel$export($a58372b18a18806e$exports, "ClusterDistribution", () => $a58372b18a18806e$export$436a960acc41e848);
+$parcel$export($a58372b18a18806e$exports, "ClusterStatus", () => $a58372b18a18806e$export$c66b56bc0ff967ca);
+$parcel$export($a58372b18a18806e$exports, "ClientState", () => $a58372b18a18806e$export$c4f81c6d30ca200f);
+$parcel$export($a58372b18a18806e$exports, "ConnectionStatus", () => $a58372b18a18806e$export$7516420eb880ab68);
+// Disable indent rule for this file because it is broken (https://github.com/typescript-eslint/typescript-eslint/issues/1824)
+/* eslint-disable @typescript-eslint/indent */ /**
+ * Enum that denotes the ordering to use in an ElectrumCluster.
+ * @enum {number}
+ * @property {0} RANDOM     Send requests to randomly selected servers in the cluster.
+ * @property {1} PRIORITY   Send requests to servers in the cluster in the order they were added.
+ */ var $a58372b18a18806e$export$161fe3707f756bf9;
+(function(ClusterOrder) {
+    ClusterOrder[ClusterOrder["RANDOM"] = 0] = "RANDOM";
+    ClusterOrder[ClusterOrder["PRIORITY"] = 1] = "PRIORITY";
+})($a58372b18a18806e$export$161fe3707f756bf9 || ($a58372b18a18806e$export$161fe3707f756bf9 = {}));
+var $a58372b18a18806e$export$436a960acc41e848;
+(function(ClusterDistribution) {
+    ClusterDistribution[ClusterDistribution["ALL"] = 0] = "ALL";
+})($a58372b18a18806e$export$436a960acc41e848 || ($a58372b18a18806e$export$436a960acc41e848 = {}));
+var $a58372b18a18806e$export$c66b56bc0ff967ca;
+(function(ClusterStatus) {
+    ClusterStatus[ClusterStatus["DISABLED"] = 0] = "DISABLED";
+    ClusterStatus[ClusterStatus["DEGRADED"] = 1] = "DEGRADED";
+    ClusterStatus[ClusterStatus["READY"] = 2] = "READY";
+})($a58372b18a18806e$export$c66b56bc0ff967ca || ($a58372b18a18806e$export$c66b56bc0ff967ca = {}));
+var $a58372b18a18806e$export$c4f81c6d30ca200f;
+(function(ClientState) {
+    ClientState[ClientState["UNAVAILABLE"] = 0] = "UNAVAILABLE";
+    ClientState[ClientState["AVAILABLE"] = 1] = "AVAILABLE";
+})($a58372b18a18806e$export$c4f81c6d30ca200f || ($a58372b18a18806e$export$c4f81c6d30ca200f = {}));
+var $a58372b18a18806e$export$7516420eb880ab68;
+(function(ConnectionStatus) {
+    ConnectionStatus[ConnectionStatus["DISCONNECTED"] = 0] = "DISCONNECTED";
+    ConnectionStatus[ConnectionStatus["CONNECTED"] = 1] = "CONNECTED";
+    ConnectionStatus[ConnectionStatus["DISCONNECTING"] = 2] = "DISCONNECTING";
+    ConnectionStatus[ConnectionStatus["CONNECTING"] = 3] = "CONNECTING";
+    ConnectionStatus[ConnectionStatus["RECONNECTING"] = 4] = "RECONNECTING";
+})($a58372b18a18806e$export$7516420eb880ab68 || ($a58372b18a18806e$export$7516420eb880ab68 = {}));
+
+
+const $5abc8fb342687c03$export$d048df559e6d3842 = {
+    TCP: {
+        Port: 50001,
+        Scheme: "tcp"
+    },
+    TCP_TLS: {
+        Port: 50002,
+        Scheme: "tcp_tls"
+    },
+    WS: {
+        Port: 50003,
+        Scheme: "ws"
+    },
+    WSS: {
+        Port: 50004,
+        Scheme: "wss"
+    }
+};
+const $5abc8fb342687c03$export$f019be48b3aacb1a = {
+    // Port number for TCP TLS connections
+    PORT: $5abc8fb342687c03$export$d048df559e6d3842.TCP_TLS.Port,
+    // Transport to connect to the Electrum server
+    TRANSPORT_SCHEME: $5abc8fb342687c03$export$d048df559e6d3842.TCP_TLS.Scheme,
+    // How long to wait before attempting to reconnect, in milliseconds.
+    RECONNECT: 5000,
+    // How long to wait for network operations before following up, in milliseconds.
+    TIMEOUT: 30000,
+    // Time between ping messages, in milliseconds. Pinging keeps the connection alive.
+    // The reason for pinging this frequently is to detect connection problems early.
+    PING_INTERVAL: 1000,
+    // How many servers are required before we trust information provided.
+    CLUSTER_CONFIDENCE: 1,
+    // How many servers we send requests to.
+    CLUSTER_DISTRIBUTION: (0, $a58372b18a18806e$export$436a960acc41e848).ALL,
+    // What order we select servers to send requests to.
+    CLUSTER_ORDER: (0, $a58372b18a18806e$export$161fe3707f756bf9).RANDOM,
+    // If we use BigInt for numbers in json when parsing and returning json response from the server.
+    USE_BIG_INT: false
+};
+
+
+
+
+
+
+
+
+
+/**
+ * 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) {
+    /**
+	 * 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.tcpSocket || 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).TCP.Scheme]: "a TCP Socket",
+            [(0, $5abc8fb342687c03$export$d048df559e6d3842).TCP_TLS.Scheme]: "an encrypted TCP socket",
+            [(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
+        throw new Error("Incorrect transport specified");
+    }
+    /**
+	 * 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}'.`);
+        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);
+        }
+        // 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();
+        // 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 {
+            // Remove all event forwarders.
+            this.webSocket.removeEventListener("close", this.eventForwarders.disconnect);
+            this.webSocket.removeEventListener("message", this.eventForwarders.wsData);
+            this.webSocket.removeEventListener("error", this.eventForwarders.wsError);
+            // Gracefully terminate the connection.
+            this.webSocket.close();
+        } catch (ignored) {
+        // close() will throw an error if the connection has not been established yet.
+        // We ignore this error, since no similar error gets thrown in the TLS Socket.
+        } finally{
+            // Remove the stored socket regardless of any thrown errors.
+            this.webSocket = 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) {
+        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");
+    }
+    /**
+	 * 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),
+            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;
+
+
+
+
+/**
+ * Wrapper around TLS/WSS sockets that gracefully separates a network stream into Electrum protocol messages.
+ *
+ * @ignore
+ */ class $1326c18f93f95fee$var$ElectrumConnection extends (0, $4QiMX$EventEmitter) {
+    /**
+	 * Sets up network configuration for an Electrum client connection.
+	 *
+	 * @param {string} application            your application name, used to identify to the electrum host.
+	 * @param {string} version                protocol version to use with the host.
+	 * @param {string} host                   fully qualified domain name or IP number of the host.
+	 * @param {number} port                   the network port of the host.
+	 * @param {TransportScheme} scheme        the transport scheme to use for connection
+	 * @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.
+	 *
+	 * @throws {Error} if `version` is not a valid version string.
+	 */ 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();
+        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.// 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 = "";
+        // 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.`);
+        // Create an initial network socket.
+        this.createSocket();
+        // Handle visibility changes when run in a browser environment.
+        if (typeof document !== "undefined") document.addEventListener("visibilitychange", this.handleVisibilityChange.bind(this));
+    }
+    /**
+	 * Returns a string for the host identifier for usage in debug messages.
+	 */ get hostIdentifier() {
+        return `${this.host}:${this.port}`;
+    }
+    /**
+	 * Create and configures a fresh socket and attaches all relevant listeners.
+	 */ createSocket() {
+        // Initialize a new ElectrumSocket
+        this.socket = new (0, $ea64e414b68fe23b$export$2e2bcd8739ae039)();
+        // Set up handlers for connection and disconnection.
+        this.socket.on("connect", this.onSocketConnect.bind(this));
+        this.socket.on("disconnect", this.onSocketDisconnect.bind(this));
+        // Set up handler for incoming data.
+        this.socket.on("data", this.parseMessageChunk.bind(this));
+    }
+    /**
+	 * Shuts down and destroys the current socket.
+	 */ destroySocket() {
+        // Close the socket connection and destroy the socket.
+        this.socket.disconnect();
+    }
+    /**
+	 * Assembles incoming data into statements and hands them off to the message parser.
+	 *
+	 * @param {string} data   data to append to the current message buffer, as a string.
+	 *
+	 * @throws {SyntaxError} if the passed statement parts are not valid JSON.
+	 */ parseMessageChunk(data) {
+        // Update the timestamp for when we last received data.
+        this.lastReceivedTimestamp = Date.now();
+        // Clear and remove all verification timers.
+        this.verifications.forEach((timer)=>clearTimeout(timer));
+        this.verifications.length = 0;
+        // Add the message to the current message buffer.
+        this.messageBuffer += data;
+        // Check if the new message buffer contains the statement delimiter.
+        while(this.messageBuffer.includes((0, $c78f59d21170b7a6$export$2e2bcd8739ae039).statementDelimiter)){
+            // Split message buffer into statements.
+            const statementParts = this.messageBuffer.split((0, $c78f59d21170b7a6$export$2e2bcd8739ae039).statementDelimiter);
+            // For as long as we still have statements to parse..
+            while(statementParts.length > 1){
+                // Move the first statement to its own variable.
+                const currentStatementList = String(statementParts.shift());
+                // Parse the statement into an object or list of objects.
+                let statementList = (0, $4QiMX$parse)(currentStatementList, null, this.useBigInt ? (0, $4QiMX$parseNumberAndBigInt) : parseFloat);
+                // Wrap the statement in an array if it is not already a batched statement list.
+                if (!Array.isArray(statementList)) statementList = [
+                    statementList
+                ];
+                // For as long as there is statements in the result set..
+                while(statementList.length > 0){
+                    // Move the first statement from the batch to its own variable.
+                    const currentStatement = statementList.shift();
+                    // If the current statement is a version negotiation response..
+                    if (currentStatement.id === "versionNegotiation") {
+                        if (currentStatement.error) // Then emit a failed version negotiation response signal.
+                        this.emit("version", {
+                            error: currentStatement.error
+                        });
+                        else // Emit a successful version negotiation response signal.
+                        this.emit("version", {
+                            software: currentStatement.result[0],
+                            protocol: currentStatement.result[1]
+                        });
+                        continue;
+                    }
+                    // If the current statement is a keep-alive response..
+                    if (currentStatement.id === "keepAlive") continue;
+                    // Emit the statements for handling higher up in the stack.
+                    this.emit("statement", currentStatement);
+                }
+            }
+            // Store the remaining statement as the current message buffer.
+            this.messageBuffer = statementParts.shift() || "";
+        }
+    }
+    /**
+	 * Sends a keep-alive message to the host.
+	 *
+	 * @returns true if the ping message was fully flushed to the socket, false if
+	 * part of the message is queued in the user memory
+	 */ ping() {
+        // Write a log message.
+        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).ping(`Sending keep-alive ping to '${this.hostIdentifier}'`);
+        // Craft a keep-alive message.
+        const message = (0, $c78f59d21170b7a6$export$2e2bcd8739ae039).buildRequestObject("server.ping", [], "keepAlive");
+        // Send the keep-alive message.
+        const status = this.send(message);
+        // Return the ping status.
+        return status;
+    }
+    /**
+	 * Initiates the network connection negotiates a protocol version. Also emits the 'connect' signal if successful.
+	 *
+	 * @throws {Error} if the socket connection fails.
+	 * @returns a promise resolving when the connection is established
+	 */ async connect() {
+        // If we are already connected return true.
+        if (this.status === (0, $a58372b18a18806e$export$7516420eb880ab68).CONNECTED) return;
+        // Indicate that the connection is connecting
+        this.status = (0, $a58372b18a18806e$export$7516420eb880ab68).CONNECTING;
+        // Define a function to wrap connection as a promise.
+        const connectionResolver = (resolve, reject)=>{
+            const rejector = (error)=>{
+                // Set the status back to disconnected
+                this.status = (0, $a58372b18a18806e$export$7516420eb880ab68).DISCONNECTED;
+                // Reject with the error as reason
+                reject(error);
+            };
+            // Replace previous error handlers to reject the promise on failure.
+            this.socket.removeAllListeners("error");
+            this.socket.once("error", rejector);
+            // Define a function to wrap version negotiation as a callback.
+            const versionNegotiator = ()=>{
+                // Write a log message to show that we have started version negotiation.
+                (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).network(`Requesting protocol version ${this.version} with '${this.hostIdentifier}'.`);
+                // remove the one-time error handler since no error was detected.
+                this.socket.removeListener("error", rejector);
+                // Build a version negotiation message.
+                const versionMessage = (0, $c78f59d21170b7a6$export$2e2bcd8739ae039).buildRequestObject("server.version", [
+                    this.application,
+                    this.version
+                ], "versionNegotiation");
+                // Define a function to wrap version validation as a function.
+                const versionValidator = (version)=>{
+                    // Check if version negotiation failed.
+                    if ((0, $a192ea5a4eec42d4$export$e1f38ab2b4ebdde6)(version)) {
+                        // Disconnect from the host.
+                        this.disconnect(true);
+                        // Declare an error message.
+                        const errorMessage = "unsupported protocol version.";
+                        // Log the error.
+                        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).errors(`Failed to connect with ${this.hostIdentifier} due to ${errorMessage}`);
+                        // Reject the connection with false since version negotiation failed.
+                        reject(errorMessage);
+                    } else if (version.protocol !== this.version && `${version.protocol}.0` !== this.version && `${version.protocol}.0.0` !== this.version) {
+                        // Disconnect from the host.
+                        this.disconnect(true);
+                        // Declare an error message.
+                        const errorMessage = `incompatible protocol version negotiated (${version.protocol} !== ${this.version}).`;
+                        // Log the error.
+                        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).errors(`Failed to connect with ${this.hostIdentifier} due to ${errorMessage}`);
+                        // Reject the connection with false since version negotiation failed.
+                        reject(errorMessage);
+                    } else {
+                        // Write a log message.
+                        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).network(`Negotiated protocol version ${version.protocol} with '${this.hostIdentifier}', powered by ${version.software}.`);
+                        // Set connection status to connected
+                        this.status = (0, $a58372b18a18806e$export$7516420eb880ab68).CONNECTED;
+                        // Emit a connect event now that the connection is usable.
+                        this.emit("connect");
+                        // Resolve the connection promise since we successfully connected and negotiated protocol version.
+                        resolve();
+                    }
+                };
+                // Listen for version negotiation once.
+                this.once("version", versionValidator);
+                // Send the version negotiation message.
+                this.send(versionMessage);
+            };
+            // Prepare the version negotiation.
+            this.socket.once("connect", versionNegotiator);
+            // Set up handler for network errors.
+            this.socket.on("error", this.onSocketError.bind(this));
+            // Connect to the server.
+            this.socket.connect(this.host, this.port, this.scheme, this.timeout);
+        };
+        // Wait until connection is established and version negotiation succeeds.
+        await new Promise(connectionResolver);
+    }
+    /**
+	 * Restores the network connection.
+	 */ async reconnect() {
+        // If a reconnect timer is set, remove it
+        await this.clearReconnectTimer();
+        // Write a log message.
+        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).network(`Trying to reconnect to '${this.hostIdentifier}'..`);
+        // Set the status to reconnecting for more accurate log messages.
+        this.status = (0, $a58372b18a18806e$export$7516420eb880ab68).RECONNECTING;
+        // Destroy and recreate the socket to get a clean slate.
+        this.destroySocket();
+        this.createSocket();
+        try {
+            // Try to connect again.
+            await this.connect();
+        } catch (error) {
+        // Do nothing as the error should be handled via the disconnect and error signals.
+        }
+    }
+    /**
+	 * Removes the current reconnect timer.
+	 */ clearReconnectTimer() {
+        // If a reconnect timer is set, remove it
+        if (this.timers.reconnect) clearTimeout(this.timers.reconnect);
+        // Reset the timer reference.
+        this.timers.reconnect = undefined;
+    }
+    /**
+	 * Removes the current keep-alive timer.
+	 */ clearKeepAliveTimer() {
+        // If a keep-alive timer is set, remove it
+        if (this.timers.keepAlive) clearTimeout(this.timers.keepAlive);
+        // Reset the timer reference.
+        this.timers.keepAlive = undefined;
+    }
+    /**
+	 * Initializes the keep alive timer loop.
+	 */ setupKeepAliveTimer() {
+        // If the keep-alive timer loop is not currently set up..
+        if (!this.timers.keepAlive) // Set a new keep-alive timer.
+        this.timers.keepAlive = setTimeout(this.ping.bind(this), this.pingInterval);
+    }
+    /**
+	 * Tears down the current connection and removes all event listeners on disconnect.
+	 *
+	 * @param {boolean} force         disconnect even if the connection has not been fully established yet.
+	 * @param {boolean} intentional   update connection state if disconnect is intentional.
+	 *
+	 * @returns true if successfully disconnected, or false if there was no connection.
+	 */ async disconnect(force = false, intentional = true) {
+        // Return early when there is nothing to disconnect from
+        if (this.status === (0, $a58372b18a18806e$export$7516420eb880ab68).DISCONNECTED && !force) // Return false to indicate that there was nothing to disconnect from.
+        return false;
+        // Update connection state if the disconnection is intentional.
+        // NOTE: The state is meant to represent what the client is requesting, but
+        //       is used internally to handle visibility changes in browsers to ensure functional reconnection.
+        if (intentional) // Set connection status to null to indicate tear-down is currently happening.
+        this.status = (0, $a58372b18a18806e$export$7516420eb880ab68).DISCONNECTING;
+        // If a keep-alive timer is set, remove it.
+        await this.clearKeepAliveTimer();
+        // If a reconnect timer is set, remove it
+        await this.clearReconnectTimer();
+        const disconnectResolver = (resolve)=>{
+            // Resolve to true after the connection emits a disconnect
+            this.once("disconnect", ()=>resolve(true));
+            // Close the connection and destroy the socket.
+            this.destroySocket();
+        };
+        // Return true to indicate that we disconnected.
+        return new Promise(disconnectResolver);
+    }
+    /**
+	 * Updates connection state based on application visibility.
+	 *
+	 * Some browsers will disconnect network connections when the browser is out of focus,
+	 * which would normally cause our reconnect-on-timeout routines to trigger, but that
+	 * results in a poor user experience since the events are not handled consistently
+	 * and sometimes it can take some time after restoring focus to the browser.
+	 *
+	 * By manually disconnecting when this happens we prevent the default reconnection routines
+	 * and make the behavior consistent across browsers.
+	 */ async handleVisibilityChange() {
+        // Disconnect when application is removed from focus.
+        if (document.visibilityState === "hidden") {
+            const forceDisconnect = true;
+            const isIntended = false;
+            this.disconnect(forceDisconnect, isIntended);
+        }
+        // Reconnect when application is returned to focus.
+        if (document.visibilityState === "visible") this.reconnect();
+    }
+    /**
+	 * Sends an arbitrary message to the server.
+	 *
+	 * @param {string} message   json encoded request object to send to the server, as a string.
+	 *
+	 * @returns true if the message was fully flushed to the socket, false if part of the message
+	 * is queued in the user memory
+	 */ send(message) {
+        // Remove the current keep-alive timer if it exists.
+        this.clearKeepAliveTimer();
+        // Get the current timestamp in milliseconds.
+        const currentTime = Date.now();
+        // Follow up and verify that the message got sent..
+        const verificationTimer = setTimeout(this.verifySend.bind(this, currentTime), this.timeout);
+        // Store the verification timer locally so that it can be cleared when data has been received.
+        this.verifications.push(verificationTimer);
+        // Set a new keep-alive timer.
+        this.setupKeepAliveTimer();
+        // Write the message to the network socket.
+        return this.socket.write(message + (0, $c78f59d21170b7a6$export$2e2bcd8739ae039).statementDelimiter);
+    }
+    // --- Event managers. --- //
+    /**
+	 * Marks the connection as timed out and schedules reconnection if we have not
+	 * received data within the expected time frame.
+	 */ verifySend(sentTimestamp) {
+        // If we haven't received any data since we last sent data out..
+        if (Number(this.lastReceivedTimestamp) < sentTimestamp) {
+            // If this connection is already disconnected, we do not change anything
+            if (this.status === (0, $a58372b18a18806e$export$7516420eb880ab68).DISCONNECTED || this.status === (0, $a58372b18a18806e$export$7516420eb880ab68).DISCONNECTING) {
+                (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).errors(`Tried to verify already disconnected connection to '${this.hostIdentifier}'`);
+                return;
+            }
+            // Remove the current keep-alive timer if it exists.
+            this.clearKeepAliveTimer();
+            // Write a notification to the logs.
+            (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).network(`Connection to '${this.hostIdentifier}' timed out.`);
+            // Close the connection to avoid re-use.
+            // NOTE: This initiates reconnection routines if the connection has not
+            //       been marked as intentionally disconnected.
+            this.socket.disconnect();
+        }
+    }
+    /**
+	 * Updates the connection status when a connection is confirmed.
+	 */ onSocketConnect() {
+        // If a reconnect timer is set, remove it.
+        this.clearReconnectTimer();
+        // Set up the initial timestamp for when we last received data from the server.
+        this.lastReceivedTimestamp = Date.now();
+        // Set up the initial keep-alive timer.
+        this.setupKeepAliveTimer();
+        // Clear all temporary error listeners.
+        this.socket.removeAllListeners("error");
+        // Set up handler for network errors.
+        this.socket.on("error", this.onSocketError.bind(this));
+    }
+    /**
+	 * Updates the connection status when a connection is ended.
+	 */ onSocketDisconnect() {
+        // Send a disconnect signal higher up the stack.
+        this.emit("disconnect");
+        // Remove the current keep-alive timer if it exists.
+        this.clearKeepAliveTimer();
+        // If this is a connection we're trying to tear down..
+        if (this.status === (0, $a58372b18a18806e$export$7516420eb880ab68).DISCONNECTING) {
+            // If a reconnect timer is set, remove it.
+            this.clearReconnectTimer();
+            // Remove all event listeners
+            this.removeAllListeners();
+            // Mark the connection as disconnected.
+            this.status = (0, $a58372b18a18806e$export$7516420eb880ab68).DISCONNECTED;
+            // Write a log message.
+            (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).network(`Disconnected from '${this.hostIdentifier}'.`);
+        } else {
+            // If this is for an established connection..
+            if (this.status === (0, $a58372b18a18806e$export$7516420eb880ab68).CONNECTED) // Write a notification to the logs.
+            (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).errors(`Connection with '${this.hostIdentifier}' was closed, trying to reconnect in ${this.reconnectInterval / 1000} seconds.`);
+            // Mark the connection as disconnected for now..
+            this.status = (0, $a58372b18a18806e$export$7516420eb880ab68).DISCONNECTED;
+            // If we don't have a pending reconnection timer..
+            if (!this.timers.reconnect) // Attempt to reconnect after one keep-alive duration.
+            this.timers.reconnect = setTimeout(this.reconnect.bind(this), this.reconnectInterval);
+        }
+    }
+    /**
+	 * Notify administrator of any unexpected errors.
+	 */ onSocketError(error) {
+        // Report a generic error if no error information is present.
+        // NOTE: When using WSS, the error event explicitly
+        //       only allows to send a "simple" event without data.
+        //       https://stackoverflow.com/a/18804298
+        if (typeof error === "undefined") // Do nothing, and instead rely on the socket disconnect event for further information.
+        return;
+        // If the DNS lookup failed.
+        if (error.code === "EAI_AGAIN") {
+            (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).errors(`Failed to look up DNS records for '${this.host}'.`);
+            return;
+        }
+        // If the connection timed out..
+        if (error.code === "ETIMEDOUT") {
+            // Log the provided timeout message.
+            (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).errors(error.message);
+            return;
+        }
+        // Log unknown error
+        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).errors(`Unknown network error ('${this.hostIdentifier}'): `, error);
+    }
+}
+var // Export the connection.
+$1326c18f93f95fee$export$2e2bcd8739ae039 = $1326c18f93f95fee$var$ElectrumConnection;
+
+
+
+
+
+
+// Acceptable parameter types for RPC messages
+const $7c0fb93e8eea922a$export$d73a2e87a509880 = function(message) {
+    return "id" in message && "error" in message;
+};
+const $7c0fb93e8eea922a$export$81276773828ff315 = function(message) {
+    return "id" in message && "result" in message;
+};
+const $7c0fb93e8eea922a$export$280de919a0cf6928 = function(message) {
+    return !("id" in message) && "method" in message;
+};
+const $7c0fb93e8eea922a$export$94e3360fcddccc76 = function(message) {
+    return "id" in message && "method" in message;
+};
+
+
+
+/**
+ * Triggers when the underlying connection is established.
+ *
+ * @event ElectrumClient#connected
+ */ /**
+ * Triggers when the underlying connection is lost.
+ *
+ * @event ElectrumClient#disconnected
+ */ /**
+ * Triggers when the remote server sends data that is not a request response.
+ *
+ * @event ElectrumClient#notification
+ */ /**
+ * High-level Electrum client that lets applications send requests and subscribe to notification events from a server.
+ */ class $620a18299ef8d6fd$var$ElectrumClient extends (0, $4QiMX$EventEmitter) {
+    /**
+	 * Initializes an Electrum client.
+	 *
+	 * @param {string} application            your application name, used to identify to the electrum host.
+	 * @param {string} version                protocol version to use with the host.
+	 * @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 {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.
+	 *
+	 * @throws {Error} if `version` is not a valid version string.
+	 */ 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.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);
+    }
+    /**
+	 * Connects to the remote server.
+	 *
+	 * @throws {Error} if the socket connection fails.
+	 * @returns a promise resolving when the connection is established.
+	 */ async connect() {
+        // Create a lock so that multiple connects/disconnects cannot race each other.
+        const unlock = await this.connectionLock.acquire();
+        try {
+            // If we are already connected, do not attempt to connect again.
+            if (this.connection.status === (0, $a58372b18a18806e$export$7516420eb880ab68).CONNECTED) return;
+            // Listen for parsed statements.
+            this.connection.on("statement", this.response.bind(this));
+            // Hook up resubscription on connection.
+            this.connection.on("connect", this.resubscribeOnConnect.bind(this));
+            // Relay connect and disconnect events.
+            this.connection.on("connect", this.emit.bind(this, "connected"));
+            this.connection.on("disconnect", this.onConnectionDisconnect.bind(this));
+            // Relay error events.
+            this.connection.on("error", this.emit.bind(this, "error"));
+            // Connect with the server.
+            await this.connection.connect();
+        } finally{
+            unlock();
+        }
+    }
+    /**
+	 * Disconnects from the remote server and removes all event listeners/subscriptions and open requests.
+	 *
+	 * @param {boolean} force                 disconnect even if the connection has not been fully established yet.
+	 * @param {boolean} retainSubscriptions   retain subscription data so they will be restored on reconnection.
+	 *
+	 * @returns true if successfully disconnected, or false if there was no connection.
+	 */ async disconnect(force = false, retainSubscriptions = false) {
+        // Create a lock so that multiple connects/disconnects cannot race each other.
+        const unlock = await this.connectionLock.acquire();
+        try {
+            if (!retainSubscriptions) {
+                // Cancel all event listeners.
+                this.removeAllListeners();
+                // Remove all subscription data
+                this.subscriptionMethods = {};
+            }
+            // For each pending request..
+            for(const index in this.requestResolvers){
+                // Reject the request.
+                const requestResolver = this.requestResolvers[index];
+                requestResolver(new Error("Manual disconnection"));
+                // Remove the request.
+                delete this.requestResolvers[index];
+            }
+            // Disconnect from the remove server.
+            return await this.connection.disconnect(force);
+        } finally{
+            unlock();
+        }
+    }
+    /**
+	 * Calls a method on the remote server with the supplied parameters.
+	 *
+	 * @param {string} method          name of the method to call.
+	 * @param {...string} parameters   one or more parameters for the method.
+	 *
+	 * @throws {Error} if the client is disconnected.
+	 * @returns a promise that resolves with the result of the method or an Error.
+	 */ async request(method, ...parameters) {
+        // If we are not connected to a server..
+        if (this.connection.status !== (0, $a58372b18a18806e$export$7516420eb880ab68).CONNECTED) // Reject the request with a disconnected error message.
+        throw new Error(`Unable to send request to a disconnected server '${this.connection.host}'.`);
+        // Increase the request ID by one.
+        this.requestId += 1;
+        // Store a copy of the request id.
+        const id = this.requestId;
+        // Format the arguments as an electrum request object.
+        const message = (0, $c78f59d21170b7a6$export$2e2bcd8739ae039).buildRequestObject(method, parameters, id);
+        // Define a function to wrap the request in a promise.
+        const requestResolver = (resolve)=>{
+            // Add a request resolver for this promise to the list of requests.
+            this.requestResolvers[id] = (error, data)=>{
+                // If the resolution failed..
+                if (error) // Resolve the promise with the error for the application to handle.
+                resolve(error);
+                else // Resolve the promise with the request results.
+                resolve(data);
+            };
+            // Send the request message to the remote server.
+            this.connection.send(message);
+        };
+        // Write a log message.
+        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).network(`Sending request '${method}' to '${this.connection.host}'`);
+        // return a promise to deliver results later.
+        return new Promise(requestResolver);
+    }
+    /**
+	 * Subscribes to the method and payload at the server.
+	 *
+	 * @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 the client is disconnected.
+	 * @returns a promise resolving when the subscription is established.
+	 */ async subscribe(method, ...parameters) {
+        // Initialize an empty list of subscription payloads, if needed.
+        if (!this.subscriptionMethods[method]) this.subscriptionMethods[method] = new Set();
+        // Store the subscription parameters to track what data we have subscribed to.
+        this.subscriptionMethods[method].add(JSON.stringify(parameters));
+        // Send initial subscription request.
+        const requestData = await this.request(method, ...parameters);
+        // Construct a notification structure to package the initial result as a notification.
+        const notification = {
+            jsonrpc: "2.0",
+            method: method,
+            params: [
+                ...parameters,
+                requestData
+            ]
+        };
+        // Manually emit an event for the initial response.
+        this.emit("notification", notification);
+    }
+    /**
+	 * Unsubscribes to the method at the server and removes any callback functions
+	 * when there are no more subscriptions for the method.
+	 *
+	 * @param {string}    method       a previously subscribed to method.
+	 * @param {...string} parameters   one or more parameters for the method.
+	 *
+	 * @throws {Error} if no subscriptions exist for the combination of the provided `method` and `parameters.
+	 * @throws {Error} if the client is disconnected.
+	 * @returns a promise resolving when the subscription is removed.
+	 */ async unsubscribe(method, ...parameters) {
+        // Throw an error if the client is disconnected.
+        if (this.connection.status !== (0, $a58372b18a18806e$export$7516420eb880ab68).CONNECTED) throw new Error(`Unable to send unsubscribe request to a disconnected server '${this.connection.host}'.`);
+        // If this method has no subscriptions..
+        if (!this.subscriptionMethods[method]) // Reject this promise with an explanation.
+        throw new Error(`Cannot unsubscribe from '${method}' since the method has no subscriptions.`);
+        // Pack up the parameters as a long string.
+        const subscriptionParameters = JSON.stringify(parameters);
+        // If the method payload could not be located..
+        if (!this.subscriptionMethods[method].has(subscriptionParameters)) // Reject this promise with an explanation.
+        throw new Error(`Cannot unsubscribe from '${method}' since it has no subscription with the given parameters.`);
+        // Remove this specific subscription payload from internal tracking.
+        this.subscriptionMethods[method].delete(subscriptionParameters);
+        // Send unsubscription request to the server
+        // NOTE: As a convenience we allow users to define the method as the subscribe or unsubscribe version.
+        await this.request(method.replace(".subscribe", ".unsubscribe"), ...parameters);
+        // Write a log message.
+        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).client(`Unsubscribed from '${String(method)}' for the '${subscriptionParameters}' parameters.`);
+    }
+    /**
+	 * Restores existing subscriptions without updating status or triggering manual callbacks.
+	 *
+	 * @throws {Error} if subscription data cannot be found for all stored event names.
+	 * @throws {Error} if the client is disconnected.
+	 * @returns a promise resolving to true when the subscriptions are restored.
+	 *
+	 * @ignore
+	 */ async resubscribeOnConnect() {
+        // Write a log message.
+        (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).client(`Connected to '${this.connection.hostIdentifier}'.`);
+        // Initialize an empty list of resubscription promises.
+        const resubscriptionPromises = [];
+        // For each method we have a subscription for..
+        for(const method in this.subscriptionMethods){
+            // .. and for each parameter we have previously been subscribed to..
+            for (const parameterJSON of this.subscriptionMethods[method].values()){
+                // restore the parameters from JSON.
+                const parameters = JSON.parse(parameterJSON);
+                // Send a subscription request.
+                resubscriptionPromises.push(this.subscribe(method, ...parameters));
+            }
+            // Wait for all re-subscriptions to complete.
+            await Promise.all(resubscriptionPromises);
+        }
+        // Write a log message if there was any subscriptions to restore.
+        if (resubscriptionPromises.length > 0) (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).client(`Restored ${resubscriptionPromises.length} previous subscriptions for '${this.connection.hostIdentifier}'`);
+    }
+    /**
+	 * Parser messages from the remote server to resolve request promises and emit subscription events.
+	 *
+	 * @param {RPCNotification | RPCResponse} message   the response message
+	 *
+	 * @throws {Error} if the message ID does not match an existing request.
+	 * @ignore
+	 */ response(message) {
+        // If the received message is a notification, we forward it to all event listeners
+        if ((0, $7c0fb93e8eea922a$export$280de919a0cf6928)(message)) {
+            // Write a log message.
+            (0, $ef5ba40c8abe5a13$export$2e2bcd8739ae039).client(`Received notification for '${message.method}' from '${this.connection.host}'`);
+            // Forward the message content to all event listeners.
+            this.emit("notification", message);
+            // Return since it does not have an associated request resolver
+            return;
+        }
+        // If the response ID is null we cannot use it to index our request resolvers
+        if (message.id === null) // Throw an internal error, this should not happen.
+        throw new Error("Internal error: Received an RPC response with ID null.");
+        // Look up which request promise we should resolve this.
+        const requestResolver = this.requestResolvers[message.id];
+        // If we do not have a request resolver for this response message..
+        if (!requestResolver) // Throw an internal error, this should not happen.
+        throw new Error("Internal error: Callback for response not available.");
+        // Remove the promise from the request list.
+        delete this.requestResolvers[message.id];
+        // If the message contains an error..
+        if ((0, $7c0fb93e8eea922a$export$d73a2e87a509880)(message)) // Forward the message error to the request resolver and omit the `result` parameter.
+        requestResolver(new Error(message.error.message));
+        else // Forward the message content to the request resolver and omit the `error` parameter
+        // (by setting it to undefined).
+        requestResolver(undefined, message.result);
+    }
+    /**
+	 * Callback function that is called when connection to the Electrum server is lost.
+	 * Aborts all active requests with an error message indicating that connection was lost.
+	 *
+	 * @ignore
+	 */ onConnectionDisconnect() {
+        // Emit a disconnection signal to any listeners.
+        this.emit("disconnected");
+        // Loop over active requests
+        for(const resolverId in this.requestResolvers){
+            // Extract request resolver for readability
+            const requestResolver = this.requestResolvers[resolverId];
+            // Resolve the active request with an error indicating that the connection was lost.
+            requestResolver(new Error("Connection lost"));
+            // Remove the promise from the request list.
+            delete this.requestResolvers[resolverId];
+        }
+    }
+}
+var // Export the client.
+$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};
+//# sourceMappingURL=index.mjs.map