@atomiqlabs/chain-evm 1.0.0-dev.51 → 1.0.0-dev.53

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,67 @@
+"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.send('');
+            }, this.pingIntervalSeconds * 1000);
+        };
+        this.websocket.onerror = (err) => {
+            console.error(`Websocket connection error: `, err);
+            if (this.destroyed)
+                return;
+            this.websocket = null;
+            if (this.pingInterval != null)
+                clearInterval(this.pingInterval);
+            //Fail all in-flight requests
+            this._disconnected();
+            console.error(`Retrying in ${this.reconnectSeconds} seconds...`);
+            this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectSeconds * 1000);
+        };
+        this.websocket.onmessage = (message) => {
+            this._processMessage(message.data);
+        };
+        this.websocket.onclose = (event) => {
+            console.error(`Websocket connection closed: `, event);
+            if (this.destroyed)
+                return;
+            this.websocket = null;
+            if (this.pingInterval != null)
+                clearInterval(this.pingInterval);
+            //Fail all in-flight requests
+            this._disconnected();
+            console.error(`Retrying in ${this.reconnectSeconds} seconds...`);
+            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/index.d.ts

@@ -40,3 +40,4 @@ export * from "./chains/botanix/BotanixInitializer";
 export * from "./chains/botanix/BotanixChainType";
 export * from "./evm/JsonRpcProviderWithRetries";
 export * from "./evm/WebSocketProviderWithRetries";
+export * from "./evm/ReconnectingWebSocketProvider";

package/dist/index.js

@@ -56,3 +56,4 @@ __exportStar(require("./chains/botanix/BotanixInitializer"), exports);
 __exportStar(require("./chains/botanix/BotanixChainType"), exports);
 __exportStar(require("./evm/JsonRpcProviderWithRetries"), exports);
 __exportStar(require("./evm/WebSocketProviderWithRetries"), exports);
+__exportStar(require("./evm/ReconnectingWebSocketProvider"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-evm",
-  "version": "1.0.0-dev.51",
+  "version": "1.0.0-dev.53",
   "description": "EVM specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/evm/ReconnectingWebSocketProvider.ts

@@ -0,0 +1,84 @@
+import {JsonRpcApiProviderOptions} from "ethers";
+import type {Networkish, WebSocketLike} from "ethers";
+import {SocketProvider} from "./SocketProvider";
+
+
+export class ReconnectingWebSocketProvider extends SocketProvider {
+
+    reconnectSeconds: number = 15;
+    pingIntervalSeconds: number = 60;
+
+    pingInterval: any;
+    reconnectTimer: any;
+
+    url: string;
+    websocket: null | WebSocketLike & {onclose?: (...args: any[]) => void, ping?: () => void};
+
+    constructor(url: string, network?: Networkish, options?: JsonRpcApiProviderOptions) {
+        super(network, options);
+        this.url = url;
+        this.connect();
+    }
+
+    private connect() {
+        this.websocket = new WebSocket(this.url);
+
+        this.websocket.onopen = () => {
+            this._connected();
+            this._start();
+
+            this.pingInterval = setInterval(() => {
+                this.websocket.send('');
+            }, this.pingIntervalSeconds * 1000);
+        };
+
+        this.websocket.onerror = (err) => {
+            console.error(`Websocket connection error: `, err);
+            if(this.destroyed) return;
+            this.websocket = null;
+            if(this.pingInterval!=null) clearInterval(this.pingInterval);
+
+            //Fail all in-flight requests
+            this._disconnected();
+
+            console.error(`Retrying in ${this.reconnectSeconds} seconds...`);
+            this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectSeconds * 1000);
+        };
+
+        this.websocket.onmessage = (message: { data: string }) => {
+            this._processMessage(message.data);
+        };
+
+        this.websocket.onclose = (event) => {
+            console.error(`Websocket connection closed: `, event);
+            if(this.destroyed) return;
+            this.websocket = null;
+            if(this.pingInterval!=null) clearInterval(this.pingInterval);
+
+            //Fail all in-flight requests
+            this._disconnected();
+
+            console.error(`Retrying in ${this.reconnectSeconds} seconds...`);
+            this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectSeconds * 1000);
+        };
+    }
+
+    async _write(message: string): Promise<void> {
+        this.websocket.send(message);
+    }
+
+    async destroy(): Promise<void> {
+        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();
+    }
+
+}

package/src/evm/SocketProvider.ts

@@ -0,0 +1,353 @@
+/**
+ *  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 {
+    assert,
+    assertArgument, EventFilter,
+    JsonRpcApiProvider,
+    JsonRpcApiProviderOptions, JsonRpcError,
+    JsonRpcPayload, JsonRpcResult, makeError,
+    Networkish,
+    Subscriber, Subscription, UnmanagedSubscriber
+} from "ethers";
+
+
+type JsonRpcSubscription = {
+    method: string,
+    params: {
+        result: any,
+        subscription: string
+    }
+};
+
+/**
+ *  A **SocketSubscriber** uses a socket transport to handle events and
+ *  should use [[_emit]] to manage the events.
+ */
+export class SocketSubscriber implements Subscriber {
+    #provider: SocketProvider;
+
+    #filter: string;
+
+    /**
+     *  The filter.
+     */
+    get filter(): Array<any> { return JSON.parse(this.#filter); }
+
+    #filterId: null | Promise<string |number>;
+    #paused: null | boolean;
+
+    #emitPromise: null | Promise<void>;
+
+    /**
+     *  Creates a new **SocketSubscriber** attached to %%provider%% listening
+     *  to %%filter%%.
+     */
+    constructor(provider: SocketProvider, filter: Array<any>) {
+        this.#provider = provider;
+        this.#filter = JSON.stringify(filter);
+        this.#filterId = null;
+        this.#paused = null;
+        this.#emitPromise = null;
+    }
+
+    start(): void {
+        this.#filterId = this.#provider.send("eth_subscribe", this.filter).then((filterId) => {;
+            this.#provider._register(filterId, this);
+            return filterId;
+        });
+    }
+
+    stop(): void {
+        (<Promise<number>>(this.#filterId)).then((filterId) => {
+            if (this.#provider.destroyed) { return; }
+            this.#provider.send("eth_unsubscribe", [ filterId ]);
+        });
+        this.#filterId = null;
+    }
+
+    // @TODO: pause should trap the current blockNumber, unsub, and on resume use getLogs
+    //        and resume
+    pause(dropWhilePaused?: boolean): void {
+        assert(dropWhilePaused, "preserve logs while paused not supported by SocketSubscriber yet",
+            "UNSUPPORTED_OPERATION", { operation: "pause(false)" });
+        this.#paused = !!dropWhilePaused;
+    }
+
+    resume(): void {
+        this.#paused = null;
+    }
+
+    /**
+     *  @_ignore:
+     */
+    _handleMessage(message: any): void {
+        if (this.#filterId == null) { return; }
+        if (this.#paused === null) {
+            let emitPromise: null | Promise<void> = this.#emitPromise;
+            if (emitPromise == null) {
+                emitPromise = this._emit(this.#provider, message);
+            } else {
+                emitPromise = emitPromise.then(async () => {
+                    await this._emit(this.#provider, message);
+                });
+            }
+            this.#emitPromise = emitPromise.then(() => {
+                if (this.#emitPromise === emitPromise) {
+                    this.#emitPromise = null;
+                }
+            });
+        }
+    }
+
+    /**
+     *  Sub-classes **must** override this to emit the events on the
+     *  provider.
+     */
+    async _emit(provider: SocketProvider, message: any): Promise<void> {
+        throw new Error("sub-classes must implemente this; _emit");
+    }
+}
+
+/**
+ *  A **SocketBlockSubscriber** listens for ``newHeads`` events and emits
+ *  ``"block"`` events.
+ */
+export class SocketBlockSubscriber extends SocketSubscriber {
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider) {
+        super(provider, [ "newHeads" ]);
+    }
+
+    async _emit(provider: SocketProvider, message: any): Promise<void> {
+        provider.emit("block", parseInt(message.number));
+    }
+}
+
+/**
+ *  A **SocketPendingSubscriber** listens for pending transacitons and emits
+ *  ``"pending"`` events.
+ */
+export class SocketPendingSubscriber extends SocketSubscriber {
+
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider) {
+        super(provider, [ "newPendingTransactions" ]);
+    }
+
+    async _emit(provider: SocketProvider, message: any): Promise<void> {
+        provider.emit("pending", message);
+    }
+}
+
+/**
+ *  A **SocketEventSubscriber** listens for event logs.
+ */
+export class SocketEventSubscriber extends SocketSubscriber {
+    #logFilter: string;
+
+    /**
+     *  The filter.
+     */
+    get logFilter(): EventFilter { return JSON.parse(this.#logFilter); }
+
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider, filter: EventFilter) {
+        super(provider, [ "logs", filter ]);
+        this.#logFilter = JSON.stringify(filter);
+    }
+
+    async _emit(provider: SocketProvider, message: any): Promise<void> {
+        provider.emit(this.logFilter, provider._wrapLog(message, provider._network));
+    }
+}
+
+/**
+ *  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 class SocketProvider extends JsonRpcApiProvider {
+    #callbacks: Map<number, { payload: JsonRpcPayload, resolve: (r: any) => void, reject: (e: Error) => void }>;
+
+    // Maps each filterId to its subscriber
+    #subs: Map<number | string, SocketSubscriber>;
+
+    // If any events come in before a subscriber has finished
+    // registering, queue them
+    #pending: Map<number | string, Array<any>>;
+
+    #connected: boolean;
+
+    /**
+     *  Creates a new **SocketProvider** connected to %%network%%.
+     *
+     *  If unspecified, the network will be discovered.
+     */
+    constructor(network?: Networkish, _options?: JsonRpcApiProviderOptions) {
+        // 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
+        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);
+        this.#callbacks = new Map();
+        this.#subs = new Map();
+        this.#pending = new Map();
+    }
+
+    // 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: Subscription): Subscriber {
+        switch (sub.type) {
+            case "close":
+                return new 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 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: number | string, subscriber: SocketSubscriber): void {
+        this.#subs.set(filterId, subscriber);
+        const pending = this.#pending.get(filterId);
+        if (pending) {
+            for (const message of pending) {
+                subscriber._handleMessage(message);
+            }
+            this.#pending.delete(filterId);
+        }
+    }
+
+    async _send(payload: JsonRpcPayload | Array<JsonRpcPayload>): Promise<Array<JsonRpcResult | JsonRpcError>> {
+        // WebSocket provider doesn't accept batches
+        assertArgument(!Array.isArray(payload), "WebSocket does not support batch send", "payload", payload);
+
+        if(!this.#connected) return Promise.reject(makeError("WebSocket not connected!", "NETWORK_ERROR"));
+
+        // Prepare a promise to respond to
+        const promise = new Promise((resolve, reject) => {
+            this.#callbacks.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 <Array<JsonRpcResult | JsonRpcError>>[ await promise ];
+    }
+
+    _connected() {
+        this.#connected = true;
+        this.resume();
+        this._forEachSubscriber(subscriber => subscriber.start());
+    }
+
+    _disconnected() {
+        this.#connected = false;
+        this.pause(true);
+
+        this.#callbacks.forEach(val => {
+            val.reject(makeError("WebSocket disconnected!", "NETWORK_ERROR"))
+        });
+        this.#callbacks.clear();
+    }
+
+    /**
+     *  Sub-classes **must** call this with messages received over their
+     *  transport to be processed and dispatched.
+     */
+    async _processMessage(message: string): Promise<void> {
+        const result = <JsonRpcResult | JsonRpcError | JsonRpcSubscription>(JSON.parse(message));
+
+        if (result && typeof(result) === "object" && "id" in result) {
+            const callback = this.#callbacks.get(result.id);
+            if (callback == null) {
+                this.emit("error", makeError("received result for unknown id", "UNKNOWN_ERROR", {
+                    reasonCode: "UNKNOWN_ID",
+                    result
+                }));
+                return;
+            }
+            this.#callbacks.delete(result.id);
+
+            callback.resolve(result);
+
+        } else if (result && (result as any).method === "eth_subscription") {
+            const filterId = (result as any).params.subscription;
+            const subscriber = this.#subs.get(filterId);
+            if (subscriber) {
+                subscriber._handleMessage((result as any).params.result);
+            } else {
+                let pending = this.#pending.get(filterId);
+                if (pending == null) {
+                    pending = [ ];
+                    this.#pending.set(filterId, pending);
+                }
+                pending.push((result as any).params.result);
+            }
+
+        } else {
+            this.emit("error", 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: string): Promise<void> {
+        throw new Error("sub-classes must override this");
+    }
+}

package/src/index.ts

@@ -49,3 +49,4 @@ export * from "./chains/botanix/BotanixChainType";
 
 export * from "./evm/JsonRpcProviderWithRetries";
 export * from "./evm/WebSocketProviderWithRetries";
+export * from "./evm/ReconnectingWebSocketProvider";

package/dist/evm/events/EVMChainEventsBrowserWS.d.ts

@@ -1,66 +0,0 @@
-import { ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent, SpvVaultClaimEvent, SpvVaultCloseEvent, SpvVaultDepositEvent, SpvVaultFrontEvent, SpvVaultOpenEvent } from "@atomiqlabs/base";
-import { IClaimHandler } from "../swaps/handlers/claim/ClaimHandlers";
-import { EVMSwapData } from "../swaps/EVMSwapData";
-import { Block, EventFilter, Log, WebSocketProvider } from "ethers";
-import { EVMSwapContract } from "../swaps/EVMSwapContract";
-import { EVMSpvVaultContract } from "../spv_swap/EVMSpvVaultContract";
-import { EVMChainInterface } from "../chain/EVMChainInterface";
-import { TypedEventLog } from "../typechain/common";
-import { EscrowManager } from "../swaps/EscrowManagerTypechain";
-import { SpvVaultManager } from "../spv_swap/SpvVaultContractTypechain";
-import { EVMTxTrace } from "../chain/modules/EVMTransactions";
-type AtomiqTypedEvent = (TypedEventLog<EscrowManager["filters"]["Initialize" | "Refund" | "Claim"]> | TypedEventLog<SpvVaultManager["filters"]["Opened" | "Deposited" | "Fronted" | "Claimed" | "Closed"]>);
-/**
- * EVM on-chain event handler for front-end systems without access to fs, uses WS or long-polling to subscribe, might lose
- *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
- *  rely purely on events
- */
-export declare class EVMChainEventsBrowserWS implements ChainEvents<EVMSwapData> {
-    protected readonly listeners: EventListener<EVMSwapData>[];
-    protected readonly provider: WebSocketProvider;
-    protected readonly chainInterface: EVMChainInterface;
-    protected readonly evmSwapContract: EVMSwapContract;
-    protected readonly evmSpvVaultContract: EVMSpvVaultContract<any>;
-    protected readonly logger: import("../../utils/Utils").LoggerType;
-    protected readonly spvVaultContractLogFilter: EventFilter;
-    protected readonly swapContractLogFilter: EventFilter;
-    protected unconfirmedEventQueue: AtomiqTypedEvent[];
-    protected stopped: boolean;
-    constructor(chainInterface: EVMChainInterface, evmSwapContract: EVMSwapContract, evmSpvVaultContract: EVMSpvVaultContract<any>);
-    findInitSwapData(call: EVMTxTrace, escrowHash: string, claimHandler: IClaimHandler<any, any>): EVMSwapData;
-    /**
-     * Returns async getter for fetching on-demand initialize event swap data
-     *
-     * @param event
-     * @param claimHandler
-     * @private
-     * @returns {() => Promise<EVMSwapData>} getter to be passed to InitializeEvent constructor
-     */
-    private getSwapDataGetter;
-    protected parseInitializeEvent(event: TypedEventLog<EscrowManager["filters"]["Initialize"]>): InitializeEvent<EVMSwapData>;
-    protected parseRefundEvent(event: TypedEventLog<EscrowManager["filters"]["Refund"]>): RefundEvent<EVMSwapData>;
-    protected parseClaimEvent(event: TypedEventLog<EscrowManager["filters"]["Claim"]>): ClaimEvent<EVMSwapData>;
-    protected parseSpvOpenEvent(event: TypedEventLog<SpvVaultManager["filters"]["Opened"]>): SpvVaultOpenEvent;
-    protected parseSpvDepositEvent(event: TypedEventLog<SpvVaultManager["filters"]["Deposited"]>): SpvVaultDepositEvent;
-    protected parseSpvFrontEvent(event: TypedEventLog<SpvVaultManager["filters"]["Fronted"]>): SpvVaultFrontEvent;
-    protected parseSpvClaimEvent(event: TypedEventLog<SpvVaultManager["filters"]["Claimed"]>): SpvVaultClaimEvent;
-    protected parseSpvCloseEvent(event: TypedEventLog<SpvVaultManager["filters"]["Closed"]>): SpvVaultCloseEvent;
-    /**
-     * Processes event as received from the chain, parses it & calls event listeners
-     *
-     * @param events
-     * @param currentBlock
-     * @protected
-     */
-    protected processEvents(events: AtomiqTypedEvent[], currentBlock?: Block): Promise<void>;
-    protected handleEvents(events: AtomiqTypedEvent[]): Promise<void>;
-    protected spvVaultContractListener: (log: Log) => void;
-    protected swapContractListener: (log: Log) => void;
-    protected blockListener: (blockNumber: number) => Promise<void>;
-    protected setupWebsocket(): Promise<void>;
-    init(): Promise<void>;
-    stop(): Promise<void>;
-    registerListener(cbk: EventListener<EVMSwapData>): void;
-    unregisterListener(cbk: EventListener<EVMSwapData>): boolean;
-}
-export {};

package/dist/evm/events/EVMChainEventsBrowserWS.js

@@ -1,264 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMChainEventsBrowserWS = void 0;
-const base_1 = require("@atomiqlabs/base");
-const EVMSwapData_1 = require("../swaps/EVMSwapData");
-const ethers_1 = require("ethers");
-const Utils_1 = require("../../utils/Utils");
-const EVMSpvVaultContract_1 = require("../spv_swap/EVMSpvVaultContract");
-/**
- * EVM on-chain event handler for front-end systems without access to fs, uses WS or long-polling to subscribe, might lose
- *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
- *  rely purely on events
- */
-class EVMChainEventsBrowserWS {
-    constructor(chainInterface, evmSwapContract, evmSpvVaultContract) {
-        this.listeners = [];
-        this.logger = (0, Utils_1.getLogger)("EVMChainEventsBrowser: ");
-        this.unconfirmedEventQueue = [];
-        this.chainInterface = chainInterface;
-        this.provider = chainInterface.provider;
-        this.evmSwapContract = evmSwapContract;
-        this.evmSpvVaultContract = evmSpvVaultContract;
-        this.spvVaultContractLogFilter = {
-            address: this.evmSpvVaultContract.contractAddress
-        };
-        this.swapContractLogFilter = {
-            address: this.evmSwapContract.contractAddress
-        };
-    }
-    findInitSwapData(call, escrowHash, claimHandler) {
-        if (call.to.toLowerCase() === this.evmSwapContract.contractAddress.toLowerCase()) {
-            const result = this.evmSwapContract.parseCalldata(call.input);
-            if (result != null && result.name === "initialize") {
-                //Found, check correct escrow hash
-                const [escrowData, signature, timeout, extraData] = result.args;
-                const escrow = EVMSwapData_1.EVMSwapData.deserializeFromStruct(escrowData, claimHandler);
-                if ("0x" + escrow.getEscrowHash() === escrowHash) {
-                    const extraDataHex = (0, ethers_1.hexlify)(extraData);
-                    if (extraDataHex.length > 2) {
-                        escrow.setExtraData(extraDataHex.substring(2));
-                    }
-                    return escrow;
-                }
-            }
-        }
-        for (let _call of call.calls) {
-            const found = this.findInitSwapData(_call, escrowHash, claimHandler);
-            if (found != null)
-                return found;
-        }
-        return null;
-    }
-    /**
-     * Returns async getter for fetching on-demand initialize event swap data
-     *
-     * @param event
-     * @param claimHandler
-     * @private
-     * @returns {() => Promise<EVMSwapData>} getter to be passed to InitializeEvent constructor
-     */
-    getSwapDataGetter(event, claimHandler) {
-        return async () => {
-            const trace = await this.chainInterface.Transactions.traceTransaction(event.transactionHash);
-            if (trace == null)
-                return null;
-            return this.findInitSwapData(trace, event.args.escrowHash, claimHandler);
-        };
-    }
-    parseInitializeEvent(event) {
-        const escrowHash = event.args.escrowHash.substring(2);
-        const claimHandlerHex = event.args.claimHandler;
-        const claimHandler = this.evmSwapContract.claimHandlersByAddress[claimHandlerHex.toLowerCase()];
-        if (claimHandler == null) {
-            this.logger.warn("parseInitializeEvent(" + escrowHash + "): Unknown claim handler with claim: " + claimHandlerHex);
-            return null;
-        }
-        const swapType = claimHandler.getType();
-        this.logger.debug("InitializeEvent escrowHash: " + escrowHash);
-        return new base_1.InitializeEvent(escrowHash, swapType, (0, Utils_1.onceAsync)(this.getSwapDataGetter(event, claimHandler)));
-    }
-    parseRefundEvent(event) {
-        const escrowHash = event.args.escrowHash.substring(2);
-        this.logger.debug("RefundEvent escrowHash: " + escrowHash);
-        return new base_1.RefundEvent(escrowHash);
-    }
-    parseClaimEvent(event) {
-        const escrowHash = event.args.escrowHash.substring(2);
-        const claimHandlerHex = event.args.claimHandler;
-        const claimHandler = this.evmSwapContract.claimHandlersByAddress[claimHandlerHex.toLowerCase()];
-        if (claimHandler == null) {
-            this.logger.warn("parseClaimEvent(" + escrowHash + "): Unknown claim handler with claim: " + claimHandlerHex);
-            return null;
-        }
-        const witnessResult = event.args.witnessResult.substring(2);
-        this.logger.debug("ClaimEvent witnessResult: " + witnessResult + " escrowHash: " + escrowHash);
-        return new base_1.ClaimEvent(escrowHash, witnessResult);
-    }
-    parseSpvOpenEvent(event) {
-        const owner = event.args.owner;
-        const vaultId = event.args.vaultId;
-        const btcTxId = Buffer.from(event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
-        const vout = Number(event.args.vout);
-        this.logger.debug("SpvOpenEvent owner: " + owner + " vaultId: " + vaultId + " utxo: " + btcTxId + ":" + vout);
-        return new base_1.SpvVaultOpenEvent(owner, vaultId, btcTxId, vout);
-    }
-    parseSpvDepositEvent(event) {
-        const [owner, vaultId] = (0, EVMSpvVaultContract_1.unpackOwnerAndVaultId)(event.args.ownerAndVaultId);
-        const amounts = [event.args.amount0, event.args.amount1];
-        const depositCount = Number(event.args.depositCount);
-        this.logger.debug("SpvDepositEvent owner: " + owner + " vaultId: " + vaultId + " depositCount: " + depositCount + " amounts: ", amounts);
-        return new base_1.SpvVaultDepositEvent(owner, vaultId, amounts, depositCount);
-    }
-    parseSpvFrontEvent(event) {
-        const [owner, vaultId] = (0, EVMSpvVaultContract_1.unpackOwnerAndVaultId)(event.args.ownerAndVaultId);
-        const btcTxId = Buffer.from(event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
-        const recipient = event.args.recipient;
-        const executionHash = event.args.executionHash;
-        const amounts = [event.args.amount0, event.args.amount1];
-        const frontingAddress = event.args.caller;
-        this.logger.debug("SpvFrontEvent owner: " + owner + " vaultId: " + vaultId + " btcTxId: " + btcTxId +
-            " recipient: " + recipient + " frontedBy: " + frontingAddress + " amounts: ", amounts);
-        return new base_1.SpvVaultFrontEvent(owner, vaultId, btcTxId, recipient, executionHash, amounts, frontingAddress);
-    }
-    parseSpvClaimEvent(event) {
-        const [owner, vaultId] = (0, EVMSpvVaultContract_1.unpackOwnerAndVaultId)(event.args.ownerAndVaultId);
-        const btcTxId = Buffer.from(event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
-        const recipient = event.args.recipient;
-        const executionHash = event.args.executionHash;
-        const amounts = [event.args.amount0, event.args.amount1];
-        const caller = event.args.caller;
-        const frontingAddress = event.args.frontingAddress;
-        const withdrawCount = Number(event.args.withdrawCount);
-        this.logger.debug("SpvClaimEvent owner: " + owner + " vaultId: " + vaultId + " btcTxId: " + btcTxId + " withdrawCount: " + withdrawCount +
-            " recipient: " + recipient + " frontedBy: " + frontingAddress + " claimedBy: " + caller + " amounts: ", amounts);
-        return new base_1.SpvVaultClaimEvent(owner, vaultId, btcTxId, recipient, executionHash, amounts, caller, frontingAddress, withdrawCount);
-    }
-    parseSpvCloseEvent(event) {
-        const btcTxId = Buffer.from(event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
-        return new base_1.SpvVaultCloseEvent(event.args.owner, event.args.vaultId, btcTxId, event.args.error);
-    }
-    /**
-     * Processes event as received from the chain, parses it & calls event listeners
-     *
-     * @param events
-     * @param currentBlock
-     * @protected
-     */
-    async processEvents(events, currentBlock) {
-        const parsedEvents = [];
-        for (let event of events) {
-            let parsedEvent;
-            switch (event.eventName) {
-                case "Claim":
-                    parsedEvent = this.parseClaimEvent(event);
-                    break;
-                case "Refund":
-                    parsedEvent = this.parseRefundEvent(event);
-                    break;
-                case "Initialize":
-                    parsedEvent = this.parseInitializeEvent(event);
-                    break;
-                case "Opened":
-                    parsedEvent = this.parseSpvOpenEvent(event);
-                    break;
-                case "Deposited":
-                    parsedEvent = this.parseSpvDepositEvent(event);
-                    break;
-                case "Fronted":
-                    parsedEvent = this.parseSpvFrontEvent(event);
-                    break;
-                case "Claimed":
-                    parsedEvent = this.parseSpvClaimEvent(event);
-                    break;
-                case "Closed":
-                    parsedEvent = this.parseSpvCloseEvent(event);
-                    break;
-            }
-            const timestamp = event.blockNumber === currentBlock?.number ? currentBlock.timestamp : await this.chainInterface.Blocks.getBlockTime(event.blockNumber);
-            parsedEvent.meta = {
-                blockTime: timestamp,
-                txId: event.transactionHash,
-                timestamp //Maybe deprecated
-            };
-            parsedEvents.push(parsedEvent);
-        }
-        for (let listener of this.listeners) {
-            await listener(parsedEvents);
-        }
-    }
-    handleEvents(events) {
-        if (this.chainInterface.config.safeBlockTag === "latest" || this.chainInterface.config.safeBlockTag === "pending") {
-            return this.processEvents(events);
-        }
-        this.unconfirmedEventQueue.push(...events);
-    }
-    async setupWebsocket() {
-        await this.provider.on(this.spvVaultContractLogFilter, this.spvVaultContractListener = (log) => {
-            let events = this.evmSpvVaultContract.Events.toTypedEvents([log]);
-            events = events.filter(val => !val.removed);
-            this.handleEvents(events);
-        });
-        await this.provider.on(this.swapContractLogFilter, this.swapContractListener = (log) => {
-            let events = this.evmSwapContract.Events.toTypedEvents([log]);
-            events = events.filter(val => !val.removed && (val.eventName === "Initialize" || val.eventName === "Refund" || val.eventName === "Claim"));
-            this.handleEvents(events);
-        });
-        const safeBlockTag = this.chainInterface.config.safeBlockTag;
-        let processing = false;
-        if (safeBlockTag !== "latest" && safeBlockTag !== "pending")
-            await this.provider.on("block", this.blockListener = async (blockNumber) => {
-                if (processing)
-                    return;
-                processing = true;
-                try {
-                    const latestSafeBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag);
-                    const events = [];
-                    this.unconfirmedEventQueue = this.unconfirmedEventQueue.filter(event => {
-                        if (event.blockNumber <= latestSafeBlock.number) {
-                            events.push(event);
-                            return false;
-                        }
-                        return true;
-                    });
-                    const blocks = {};
-                    for (let event of events) {
-                        const block = blocks[event.blockNumber] ?? (blocks[event.blockNumber] = await this.provider.getBlock(event.blockNumber));
-                        if (block.hash === event.blockHash) {
-                            //Valid event
-                            await this.processEvents([event], block);
-                        }
-                        else {
-                            //Block hash doesn't match
-                        }
-                    }
-                }
-                catch (e) {
-                    this.logger.error(`on('block'): Error when processing new block ${blockNumber}:`, e);
-                }
-                processing = false;
-            });
-    }
-    async init() {
-        await this.setupWebsocket();
-        this.stopped = false;
-    }
-    async stop() {
-        this.stopped = true;
-        await this.provider.off(this.spvVaultContractLogFilter, this.spvVaultContractListener);
-        await this.provider.off(this.swapContractLogFilter, this.swapContractListener);
-        await this.provider.off("block", this.blockListener);
-    }
-    registerListener(cbk) {
-        this.listeners.push(cbk);
-    }
-    unregisterListener(cbk) {
-        const index = this.listeners.indexOf(cbk);
-        if (index >= 0) {
-            this.listeners.splice(index, 1);
-            return true;
-        }
-        return false;
-    }
-}
-exports.EVMChainEventsBrowserWS = EVMChainEventsBrowserWS;