@atomiqlabs/chain-evm 1.0.0-dev.50 → 1.0.0-dev.52

package/dist/chains/botanix/BotanixChainType.d.ts

@@ -10,5 +10,4 @@ import { EVMSpvWithdrawalData } from "../../evm/spv_swap/EVMSpvWithdrawalData";
 import { EVMSwapContract } from "../../evm/swaps/EVMSwapContract";
 import { EVMBtcRelay } from "../../evm/btcrelay/EVMBtcRelay";
 import { EVMSpvVaultContract } from "../../evm/spv_swap/EVMSpvVaultContract";
-import { EVMChainEventsBrowserWS } from "../../evm/events/EVMChainEventsBrowserWS";
-export type BotanixChainType = ChainType<"BOTANIX", never, EVMPreFetchVerification, EVMTx, EVMSigner, EVMSwapData, EVMSwapContract<"BOTANIX">, EVMChainInterface<"BOTANIX", 3636>, EVMChainEventsBrowser | EVMChainEventsBrowserWS, EVMBtcRelay<any>, EVMSpvVaultData, EVMSpvWithdrawalData, EVMSpvVaultContract<"BOTANIX">>;
+export type BotanixChainType = ChainType<"BOTANIX", never, EVMPreFetchVerification, EVMTx, EVMSigner, EVMSwapData, EVMSwapContract<"BOTANIX">, EVMChainInterface<"BOTANIX", 3636>, EVMChainEventsBrowser, EVMBtcRelay<any>, EVMSpvVaultData, EVMSpvWithdrawalData, EVMSpvVaultContract<"BOTANIX">>;

package/dist/chains/botanix/BotanixInitializer.js

@@ -12,7 +12,6 @@ const EVMChainEventsBrowser_1 = require("../../evm/events/EVMChainEventsBrowser"
 const EVMSwapData_1 = require("../../evm/swaps/EVMSwapData");
 const EVMSpvVaultData_1 = require("../../evm/spv_swap/EVMSpvVaultData");
 const EVMSpvWithdrawalData_1 = require("../../evm/spv_swap/EVMSpvWithdrawalData");
-const EVMChainEventsBrowserWS_1 = require("../../evm/events/EVMChainEventsBrowserWS");
 const BotanixChainIds = {
     MAINNET: null,
     TESTNET: 3636
@@ -99,9 +98,7 @@ function initializeBotanix(options, bitcoinRpc, network) {
         }
     });
     const spvVaultContract = new EVMSpvVaultContract_1.EVMSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract ?? defaultContractAddresses.spvVaultContract, options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight);
-    const chainEvents = provider.websocket != null ?
-        new EVMChainEventsBrowserWS_1.EVMChainEventsBrowserWS(chainInterface, swapContract, spvVaultContract) :
-        new EVMChainEventsBrowser_1.EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
+    const chainEvents = new EVMChainEventsBrowser_1.EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
     return {
         chainId: "BOTANIX",
         btcRelay,

package/dist/chains/citrea/CitreaChainType.d.ts

@@ -10,5 +10,4 @@ import { EVMSpvWithdrawalData } from "../../evm/spv_swap/EVMSpvWithdrawalData";
 import { CitreaSwapContract } from "./CitreaSwapContract";
 import { CitreaBtcRelay } from "./CitreaBtcRelay";
 import { CitreaSpvVaultContract } from "./CitreaSpvVaultContract";
-import { EVMChainEventsBrowserWS } from "../../evm/events/EVMChainEventsBrowserWS";
-export type CitreaChainType = ChainType<"CITREA", never, EVMPreFetchVerification, EVMTx, EVMSigner, EVMSwapData, CitreaSwapContract, EVMChainInterface<"CITREA", 5115>, EVMChainEventsBrowser | EVMChainEventsBrowserWS, CitreaBtcRelay<any>, EVMSpvVaultData, EVMSpvWithdrawalData, CitreaSpvVaultContract>;
+export type CitreaChainType = ChainType<"CITREA", never, EVMPreFetchVerification, EVMTx, EVMSigner, EVMSwapData, CitreaSwapContract, EVMChainInterface<"CITREA", 5115>, EVMChainEventsBrowser, CitreaBtcRelay<any>, EVMSpvVaultData, EVMSpvWithdrawalData, CitreaSpvVaultContract>;

package/dist/chains/citrea/CitreaInitializer.js

@@ -13,7 +13,6 @@ const CitreaBtcRelay_1 = require("./CitreaBtcRelay");
 const CitreaSwapContract_1 = require("./CitreaSwapContract");
 const CitreaTokens_1 = require("./CitreaTokens");
 const CitreaSpvVaultContract_1 = require("./CitreaSpvVaultContract");
-const EVMChainEventsBrowserWS_1 = require("../../evm/events/EVMChainEventsBrowserWS");
 const CitreaChainIds = {
     MAINNET: null,
     TESTNET4: 5115
@@ -106,9 +105,7 @@ function initializeCitrea(options, bitcoinRpc, network) {
         }
     });
     const spvVaultContract = new CitreaSpvVaultContract_1.CitreaSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract ?? defaultContractAddresses.spvVaultContract, options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight);
-    const chainEvents = provider.websocket != null ?
-        new EVMChainEventsBrowserWS_1.EVMChainEventsBrowserWS(chainInterface, swapContract, spvVaultContract) :
-        new EVMChainEventsBrowser_1.EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
+    const chainEvents = new EVMChainEventsBrowser_1.EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
     return {
         chainId: "CITREA",
         btcRelay,

package/dist/evm/ReconnectingWebSocketProvider.d.ts

@@ -0,0 +1,18 @@
+import { JsonRpcApiProviderOptions } from "ethers";
+import type { Networkish, WebSocketLike } from "ethers";
+import { SocketProvider } from "./SocketProvider";
+export declare class ReconnectingWebSocketProvider extends SocketProvider {
+    reconnectSeconds: number;
+    pingIntervalSeconds: number;
+    pingInterval: any;
+    reconnectTimer: any;
+    url: string;
+    websocket: null | (WebSocketLike & {
+        onclose?: (...args: any[]) => void;
+        ping?: () => void;
+    });
+    constructor(url: string, network?: Networkish, options?: JsonRpcApiProviderOptions);
+    private connect;
+    _write(message: string): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/evm/ReconnectingWebSocketProvider.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReconnectingWebSocketProvider = void 0;
+const SocketProvider_1 = require("./SocketProvider");
+class ReconnectingWebSocketProvider extends SocketProvider_1.SocketProvider {
+    constructor(url, network, options) {
+        super(network, options);
+        this.reconnectSeconds = 15;
+        this.pingIntervalSeconds = 60;
+        this.url = url;
+        this.connect();
+    }
+    connect() {
+        this.websocket = new WebSocket(this.url);
+        this.websocket.onopen = () => {
+            this._connected();
+            this._start();
+            this.pingInterval = setInterval(() => {
+                this.websocket.ping();
+            }, this.pingIntervalSeconds * 1000);
+        };
+        this.websocket.onerror = (err) => {
+            if (this.destroyed)
+                return;
+            this.websocket = null;
+            if (this.pingInterval != null)
+                clearInterval(this.pingInterval);
+            //Fail all in-flight requests
+            this._disconnected();
+            console.error(`Websocket connection error retrying in ${this.reconnectSeconds} seconds...`, err);
+            this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectSeconds * 1000);
+        };
+        this.websocket.onmessage = (message) => {
+            this._processMessage(message.data);
+        };
+        this.websocket.onclose = (event) => {
+            if (this.destroyed)
+                return;
+            this.websocket = null;
+            if (this.pingInterval != null)
+                clearInterval(this.pingInterval);
+            //Fail all in-flight requests
+            this._disconnected();
+            console.error(`Websocket connection closed retrying in ${this.reconnectSeconds} seconds...`, event);
+            this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectSeconds * 1000);
+        };
+    }
+    async _write(message) {
+        this.websocket.send(message);
+    }
+    async destroy() {
+        if (this.websocket != null) {
+            this.websocket.close();
+            this.websocket = null;
+        }
+        if (this.reconnectTimer != null) {
+            clearTimeout(this.reconnectTimer);
+        }
+        if (this.pingInterval != null) {
+            clearInterval(this.pingInterval);
+        }
+        super.destroy();
+    }
+}
+exports.ReconnectingWebSocketProvider = ReconnectingWebSocketProvider;

package/dist/evm/SocketProvider.d.ts

@@ -0,0 +1,110 @@
+/**
+ *  Generic long-lived socket provider.
+ *
+ *  Sub-classing notes
+ *  - a sub-class MUST call the `_start()` method once connected
+ *  - a sub-class MUST override the `_write(string)` method
+ *  - a sub-class MUST call `_processMessage(string)` for each message
+ *
+ *  @_subsection: api/providers/abstract-provider:Socket Providers  [about-socketProvider]
+ */
+import { EventFilter, JsonRpcApiProvider, JsonRpcApiProviderOptions, JsonRpcError, JsonRpcPayload, JsonRpcResult, Networkish, Subscriber, Subscription } from "ethers";
+/**
+ *  A **SocketSubscriber** uses a socket transport to handle events and
+ *  should use [[_emit]] to manage the events.
+ */
+export declare class SocketSubscriber implements Subscriber {
+    #private;
+    /**
+     *  The filter.
+     */
+    get filter(): Array<any>;
+    /**
+     *  Creates a new **SocketSubscriber** attached to %%provider%% listening
+     *  to %%filter%%.
+     */
+    constructor(provider: SocketProvider, filter: Array<any>);
+    start(): void;
+    stop(): void;
+    pause(dropWhilePaused?: boolean): void;
+    resume(): void;
+    /**
+     *  @_ignore:
+     */
+    _handleMessage(message: any): void;
+    /**
+     *  Sub-classes **must** override this to emit the events on the
+     *  provider.
+     */
+    _emit(provider: SocketProvider, message: any): Promise<void>;
+}
+/**
+ *  A **SocketBlockSubscriber** listens for ``newHeads`` events and emits
+ *  ``"block"`` events.
+ */
+export declare class SocketBlockSubscriber extends SocketSubscriber {
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider);
+    _emit(provider: SocketProvider, message: any): Promise<void>;
+}
+/**
+ *  A **SocketPendingSubscriber** listens for pending transacitons and emits
+ *  ``"pending"`` events.
+ */
+export declare class SocketPendingSubscriber extends SocketSubscriber {
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider);
+    _emit(provider: SocketProvider, message: any): Promise<void>;
+}
+/**
+ *  A **SocketEventSubscriber** listens for event logs.
+ */
+export declare class SocketEventSubscriber extends SocketSubscriber {
+    #private;
+    /**
+     *  The filter.
+     */
+    get logFilter(): EventFilter;
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider, filter: EventFilter);
+    _emit(provider: SocketProvider, message: any): Promise<void>;
+}
+/**
+ *  A **SocketProvider** is backed by a long-lived connection over a
+ *  socket, which can subscribe and receive real-time messages over
+ *  its communication channel.
+ */
+export declare class SocketProvider extends JsonRpcApiProvider {
+    #private;
+    /**
+     *  Creates a new **SocketProvider** connected to %%network%%.
+     *
+     *  If unspecified, the network will be discovered.
+     */
+    constructor(network?: Networkish, _options?: JsonRpcApiProviderOptions);
+    _getSubscriber(sub: Subscription): Subscriber;
+    /**
+     *  Register a new subscriber. This is used internalled by Subscribers
+     *  and generally is unecessary unless extending capabilities.
+     */
+    _register(filterId: number | string, subscriber: SocketSubscriber): void;
+    _send(payload: JsonRpcPayload | Array<JsonRpcPayload>): Promise<Array<JsonRpcResult | JsonRpcError>>;
+    _connected(): void;
+    _disconnected(): void;
+    /**
+     *  Sub-classes **must** call this with messages received over their
+     *  transport to be processed and dispatched.
+     */
+    _processMessage(message: string): Promise<void>;
+    /**
+     *  Sub-classes **must** override this to send %%message%% over their
+     *  transport.
+     */
+    _write(message: string): Promise<void>;
+}

package/dist/evm/SocketProvider.js

@@ -0,0 +1,322 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _SocketSubscriber_provider, _SocketSubscriber_filter, _SocketSubscriber_filterId, _SocketSubscriber_paused, _SocketSubscriber_emitPromise, _SocketEventSubscriber_logFilter, _SocketProvider_callbacks, _SocketProvider_subs, _SocketProvider_pending, _SocketProvider_connected;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketProvider = exports.SocketEventSubscriber = exports.SocketPendingSubscriber = exports.SocketBlockSubscriber = exports.SocketSubscriber = void 0;
+/**
+ *  Generic long-lived socket provider.
+ *
+ *  Sub-classing notes
+ *  - a sub-class MUST call the `_start()` method once connected
+ *  - a sub-class MUST override the `_write(string)` method
+ *  - a sub-class MUST call `_processMessage(string)` for each message
+ *
+ *  @_subsection: api/providers/abstract-provider:Socket Providers  [about-socketProvider]
+ */
+const ethers_1 = require("ethers");
+/**
+ *  A **SocketSubscriber** uses a socket transport to handle events and
+ *  should use [[_emit]] to manage the events.
+ */
+class SocketSubscriber {
+    /**
+     *  The filter.
+     */
+    get filter() { return JSON.parse(__classPrivateFieldGet(this, _SocketSubscriber_filter, "f")); }
+    /**
+     *  Creates a new **SocketSubscriber** attached to %%provider%% listening
+     *  to %%filter%%.
+     */
+    constructor(provider, filter) {
+        _SocketSubscriber_provider.set(this, void 0);
+        _SocketSubscriber_filter.set(this, void 0);
+        _SocketSubscriber_filterId.set(this, void 0);
+        _SocketSubscriber_paused.set(this, void 0);
+        _SocketSubscriber_emitPromise.set(this, void 0);
+        __classPrivateFieldSet(this, _SocketSubscriber_provider, provider, "f");
+        __classPrivateFieldSet(this, _SocketSubscriber_filter, JSON.stringify(filter), "f");
+        __classPrivateFieldSet(this, _SocketSubscriber_filterId, null, "f");
+        __classPrivateFieldSet(this, _SocketSubscriber_paused, null, "f");
+        __classPrivateFieldSet(this, _SocketSubscriber_emitPromise, null, "f");
+    }
+    start() {
+        __classPrivateFieldSet(this, _SocketSubscriber_filterId, __classPrivateFieldGet(this, _SocketSubscriber_provider, "f").send("eth_subscribe", this.filter).then((filterId) => {
+            ;
+            __classPrivateFieldGet(this, _SocketSubscriber_provider, "f")._register(filterId, this);
+            return filterId;
+        }), "f");
+    }
+    stop() {
+        (__classPrivateFieldGet(this, _SocketSubscriber_filterId, "f")).then((filterId) => {
+            if (__classPrivateFieldGet(this, _SocketSubscriber_provider, "f").destroyed) {
+                return;
+            }
+            __classPrivateFieldGet(this, _SocketSubscriber_provider, "f").send("eth_unsubscribe", [filterId]);
+        });
+        __classPrivateFieldSet(this, _SocketSubscriber_filterId, null, "f");
+    }
+    // @TODO: pause should trap the current blockNumber, unsub, and on resume use getLogs
+    //        and resume
+    pause(dropWhilePaused) {
+        (0, ethers_1.assert)(dropWhilePaused, "preserve logs while paused not supported by SocketSubscriber yet", "UNSUPPORTED_OPERATION", { operation: "pause(false)" });
+        __classPrivateFieldSet(this, _SocketSubscriber_paused, !!dropWhilePaused, "f");
+    }
+    resume() {
+        __classPrivateFieldSet(this, _SocketSubscriber_paused, null, "f");
+    }
+    /**
+     *  @_ignore:
+     */
+    _handleMessage(message) {
+        if (__classPrivateFieldGet(this, _SocketSubscriber_filterId, "f") == null) {
+            return;
+        }
+        if (__classPrivateFieldGet(this, _SocketSubscriber_paused, "f") === null) {
+            let emitPromise = __classPrivateFieldGet(this, _SocketSubscriber_emitPromise, "f");
+            if (emitPromise == null) {
+                emitPromise = this._emit(__classPrivateFieldGet(this, _SocketSubscriber_provider, "f"), message);
+            }
+            else {
+                emitPromise = emitPromise.then(async () => {
+                    await this._emit(__classPrivateFieldGet(this, _SocketSubscriber_provider, "f"), message);
+                });
+            }
+            __classPrivateFieldSet(this, _SocketSubscriber_emitPromise, emitPromise.then(() => {
+                if (__classPrivateFieldGet(this, _SocketSubscriber_emitPromise, "f") === emitPromise) {
+                    __classPrivateFieldSet(this, _SocketSubscriber_emitPromise, null, "f");
+                }
+            }), "f");
+        }
+    }
+    /**
+     *  Sub-classes **must** override this to emit the events on the
+     *  provider.
+     */
+    async _emit(provider, message) {
+        throw new Error("sub-classes must implemente this; _emit");
+    }
+}
+exports.SocketSubscriber = SocketSubscriber;
+_SocketSubscriber_provider = new WeakMap(), _SocketSubscriber_filter = new WeakMap(), _SocketSubscriber_filterId = new WeakMap(), _SocketSubscriber_paused = new WeakMap(), _SocketSubscriber_emitPromise = new WeakMap();
+/**
+ *  A **SocketBlockSubscriber** listens for ``newHeads`` events and emits
+ *  ``"block"`` events.
+ */
+class SocketBlockSubscriber extends SocketSubscriber {
+    /**
+     *  @_ignore:
+     */
+    constructor(provider) {
+        super(provider, ["newHeads"]);
+    }
+    async _emit(provider, message) {
+        provider.emit("block", parseInt(message.number));
+    }
+}
+exports.SocketBlockSubscriber = SocketBlockSubscriber;
+/**
+ *  A **SocketPendingSubscriber** listens for pending transacitons and emits
+ *  ``"pending"`` events.
+ */
+class SocketPendingSubscriber extends SocketSubscriber {
+    /**
+     *  @_ignore:
+     */
+    constructor(provider) {
+        super(provider, ["newPendingTransactions"]);
+    }
+    async _emit(provider, message) {
+        provider.emit("pending", message);
+    }
+}
+exports.SocketPendingSubscriber = SocketPendingSubscriber;
+/**
+ *  A **SocketEventSubscriber** listens for event logs.
+ */
+class SocketEventSubscriber extends SocketSubscriber {
+    /**
+     *  The filter.
+     */
+    get logFilter() { return JSON.parse(__classPrivateFieldGet(this, _SocketEventSubscriber_logFilter, "f")); }
+    /**
+     *  @_ignore:
+     */
+    constructor(provider, filter) {
+        super(provider, ["logs", filter]);
+        _SocketEventSubscriber_logFilter.set(this, void 0);
+        __classPrivateFieldSet(this, _SocketEventSubscriber_logFilter, JSON.stringify(filter), "f");
+    }
+    async _emit(provider, message) {
+        provider.emit(this.logFilter, provider._wrapLog(message, provider._network));
+    }
+}
+exports.SocketEventSubscriber = SocketEventSubscriber;
+_SocketEventSubscriber_logFilter = new WeakMap();
+/**
+ *  A **SocketProvider** is backed by a long-lived connection over a
+ *  socket, which can subscribe and receive real-time messages over
+ *  its communication channel.
+ */
+class SocketProvider extends ethers_1.JsonRpcApiProvider {
+    /**
+     *  Creates a new **SocketProvider** connected to %%network%%.
+     *
+     *  If unspecified, the network will be discovered.
+     */
+    constructor(network, _options) {
+        // Copy the options
+        const options = Object.assign({}, (_options != null) ? _options : {});
+        // Support for batches is generally not supported for
+        // connection-base providers; if this changes in the future
+        // the _send should be updated to reflect this
+        (0, ethers_1.assertArgument)(options.batchMaxCount == null || options.batchMaxCount === 1, "sockets-based providers do not support batches", "options.batchMaxCount", _options);
+        options.batchMaxCount = 1;
+        // Socket-based Providers (generally) cannot change their network,
+        // since they have a long-lived connection; but let people override
+        // this if they have just cause.
+        if (options.staticNetwork == null) {
+            options.staticNetwork = true;
+        }
+        super(network, options);
+        _SocketProvider_callbacks.set(this, void 0);
+        // Maps each filterId to its subscriber
+        _SocketProvider_subs.set(this, void 0);
+        // If any events come in before a subscriber has finished
+        // registering, queue them
+        _SocketProvider_pending.set(this, void 0);
+        _SocketProvider_connected.set(this, void 0);
+        __classPrivateFieldSet(this, _SocketProvider_callbacks, new Map(), "f");
+        __classPrivateFieldSet(this, _SocketProvider_subs, new Map(), "f");
+        __classPrivateFieldSet(this, _SocketProvider_pending, new Map(), "f");
+    }
+    // This value is only valid after _start has been called
+    /*
+    get _network(): Network {
+        if (this.#network == null) {
+            throw new Error("this shouldn't happen");
+        }
+        return this.#network.clone();
+    }
+    */
+    _getSubscriber(sub) {
+        switch (sub.type) {
+            case "close":
+                return new ethers_1.UnmanagedSubscriber("close");
+            case "block":
+                return new SocketBlockSubscriber(this);
+            case "pending":
+                return new SocketPendingSubscriber(this);
+            case "event":
+                return new SocketEventSubscriber(this, sub.filter);
+            case "orphan":
+                // Handled auto-matically within AbstractProvider
+                // when the log.removed = true
+                if (sub.filter.orphan === "drop-log") {
+                    return new ethers_1.UnmanagedSubscriber("drop-log");
+                }
+        }
+        return super._getSubscriber(sub);
+    }
+    /**
+     *  Register a new subscriber. This is used internalled by Subscribers
+     *  and generally is unecessary unless extending capabilities.
+     */
+    _register(filterId, subscriber) {
+        __classPrivateFieldGet(this, _SocketProvider_subs, "f").set(filterId, subscriber);
+        const pending = __classPrivateFieldGet(this, _SocketProvider_pending, "f").get(filterId);
+        if (pending) {
+            for (const message of pending) {
+                subscriber._handleMessage(message);
+            }
+            __classPrivateFieldGet(this, _SocketProvider_pending, "f").delete(filterId);
+        }
+    }
+    async _send(payload) {
+        // WebSocket provider doesn't accept batches
+        (0, ethers_1.assertArgument)(!Array.isArray(payload), "WebSocket does not support batch send", "payload", payload);
+        if (!__classPrivateFieldGet(this, _SocketProvider_connected, "f"))
+            return Promise.reject((0, ethers_1.makeError)("WebSocket not connected!", "NETWORK_ERROR"));
+        // Prepare a promise to respond to
+        const promise = new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").set(payload.id, { payload, resolve, reject });
+        });
+        // Wait until the socket is connected before writing to it
+        await this._waitUntilReady();
+        // Write the request to the socket
+        await this._write(JSON.stringify(payload));
+        return [await promise];
+    }
+    _connected() {
+        __classPrivateFieldSet(this, _SocketProvider_connected, true, "f");
+        this.resume();
+        this._forEachSubscriber(subscriber => subscriber.start());
+    }
+    _disconnected() {
+        __classPrivateFieldSet(this, _SocketProvider_connected, false, "f");
+        this.pause(true);
+        __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").forEach(val => {
+            val.reject((0, ethers_1.makeError)("WebSocket disconnected!", "NETWORK_ERROR"));
+        });
+        __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").clear();
+    }
+    /**
+     *  Sub-classes **must** call this with messages received over their
+     *  transport to be processed and dispatched.
+     */
+    async _processMessage(message) {
+        const result = (JSON.parse(message));
+        if (result && typeof (result) === "object" && "id" in result) {
+            const callback = __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").get(result.id);
+            if (callback == null) {
+                this.emit("error", (0, ethers_1.makeError)("received result for unknown id", "UNKNOWN_ERROR", {
+                    reasonCode: "UNKNOWN_ID",
+                    result
+                }));
+                return;
+            }
+            __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").delete(result.id);
+            callback.resolve(result);
+        }
+        else if (result && result.method === "eth_subscription") {
+            const filterId = result.params.subscription;
+            const subscriber = __classPrivateFieldGet(this, _SocketProvider_subs, "f").get(filterId);
+            if (subscriber) {
+                subscriber._handleMessage(result.params.result);
+            }
+            else {
+                let pending = __classPrivateFieldGet(this, _SocketProvider_pending, "f").get(filterId);
+                if (pending == null) {
+                    pending = [];
+                    __classPrivateFieldGet(this, _SocketProvider_pending, "f").set(filterId, pending);
+                }
+                pending.push(result.params.result);
+            }
+        }
+        else {
+            this.emit("error", (0, ethers_1.makeError)("received unexpected message", "UNKNOWN_ERROR", {
+                reasonCode: "UNEXPECTED_MESSAGE",
+                result
+            }));
+            return;
+        }
+    }
+    /**
+     *  Sub-classes **must** override this to send %%message%% over their
+     *  transport.
+     */
+    async _write(message) {
+        throw new Error("sub-classes must override this");
+    }
+}
+exports.SocketProvider = SocketProvider;
+_SocketProvider_callbacks = new WeakMap(), _SocketProvider_subs = new WeakMap(), _SocketProvider_pending = new WeakMap(), _SocketProvider_connected = new WeakMap();

package/dist/evm/WebSocketProviderWithRetries.d.ts

@@ -0,0 +1,15 @@
+import { JsonRpcApiProviderOptions, WebSocketProvider } from "ethers";
+import type { Networkish, WebSocketCreator, WebSocketLike } from "ethers";
+export declare class WebSocketProviderWithRetries extends WebSocketProvider {
+    readonly retryPolicy?: {
+        maxRetries?: number;
+        delay?: number;
+        exponential?: boolean;
+    };
+    constructor(url: string | WebSocketLike | WebSocketCreator, network?: Networkish, options?: JsonRpcApiProviderOptions & {
+        maxRetries?: number;
+        delay?: number;
+        exponential?: boolean;
+    });
+    send(method: string, params: Array<any> | Record<string, any>): Promise<any>;
+}

package/dist/evm/WebSocketProviderWithRetries.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketProviderWithRetries = void 0;
+const ethers_1 = require("ethers");
+const Utils_1 = require("../utils/Utils");
+class WebSocketProviderWithRetries extends ethers_1.WebSocketProvider {
+    constructor(url, network, options) {
+        super(url, network, options);
+        this.retryPolicy = options;
+    }
+    send(method, params) {
+        return (0, Utils_1.tryWithRetries)(() => super.send(method, params), this.retryPolicy, e => {
+            return false;
+            // if(e?.error?.code!=null) return false; //Error returned by the RPC
+            // return true;
+        });
+    }
+}
+exports.WebSocketProviderWithRetries = WebSocketProviderWithRetries;

package/dist/evm/events/EVMChainEvents.js

@@ -61,6 +61,8 @@ class EVMChainEvents extends EVMChainEventsBrowser_1.EVMChainEventsBrowser {
     }
     async init() {
         const lastState = await this.getLastEventData();
+        if (this.provider.websocket != null)
+            await this.setupWebsocket();
         await this.setupPoll(lastState, (newState) => this.saveLastEventData(newState));
     }
 }