@atomiqlabs/chain-evm 1.0.0-dev.61 → 1.0.0-dev.63

package/dist/evm/ReconnectingWebSocketProvider.js

@@ -53,7 +53,6 @@ class ReconnectingWebSocketProvider extends SocketProvider_1.SocketProvider {
         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);

package/dist/evm/SocketProvider.js

@@ -251,12 +251,12 @@ class SocketProvider extends ethers_1.JsonRpcApiProvider {
             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 });
-            setTimeout(() => {
+            const timeout = setTimeout(() => {
                 if (__classPrivateFieldGet(this, _SocketProvider_callbacks, "f").delete(payload.id)) {
                     reject((0, ethers_1.makeError)("Request timed out!", "NETWORK_ERROR"));
                 }
             }, this.requestTimeoutSeconds * 1000);
+            __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").set(payload.id, { payload, resolve, reject, timeout });
         });
         // Write the request to the socket
         if (__classPrivateFieldGet(this, _SocketProvider_connected, "f"))
@@ -275,6 +275,7 @@ class SocketProvider extends ethers_1.JsonRpcApiProvider {
         __classPrivateFieldSet(this, _SocketProvider_connected, false, "f");
         this.pause(true);
         __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").forEach(val => {
+            clearTimeout(val.timeout);
             val.reject((0, ethers_1.makeError)("WebSocket disconnected!", "NETWORK_ERROR"));
         });
         __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").clear();
@@ -295,6 +296,7 @@ class SocketProvider extends ethers_1.JsonRpcApiProvider {
                 return;
             }
             __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").delete(result.id);
+            clearTimeout(callback.timeout);
             callback.resolve(result);
         }
         else if (result && result.method === "eth_subscription") {

package/dist/evm/events/EVMChainEventsBrowser.js

@@ -35,13 +35,13 @@ class EVMChainEventsBrowser {
         };
     }
     addProcessedEvent(event) {
-        this.processedEvents[this.processedEventsIndex] = event.transactionHash + ":" + event.transactionIndex;
+        this.processedEvents[this.processedEventsIndex] = event.transactionHash + ":" + event.index;
         this.processedEventsIndex += 1;
         if (this.processedEventsIndex >= PROCESSED_EVENTS_BACKLOG)
             this.processedEventsIndex = 0;
     }
     isEventProcessed(event) {
-        return this.processedEvents.includes(event.transactionHash + ":" + event.transactionIndex);
+        return this.processedEvents.includes(event.transactionHash + ":" + event.index);
     }
     findInitSwapData(call, escrowHash, claimHandler) {
         if (call.to.toLowerCase() === this.evmSwapContract.contractAddress.toLowerCase()) {
@@ -163,7 +163,7 @@ class EVMChainEventsBrowser {
      */
     async processEvents(events, currentBlock) {
         for (let event of events) {
-            const eventIdentifier = event.transactionHash + ":" + event.transactionIndex;
+            const eventIdentifier = event.transactionHash + ":" + event.index;
             if (this.isEventProcessed(event)) {
                 this.logger.debug("processEvents(): skipping already processed event: " + eventIdentifier);
                 continue;
@@ -335,6 +335,8 @@ class EVMChainEventsBrowser {
             await this.provider.on("block", this.blockListener = async (blockNumber) => {
                 if (processing)
                     return;
+                if (this.unconfirmedEventQueue.length === 0)
+                    return;
                 processing = true;
                 try {
                     const latestSafeBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag);

package/dist/evm/providers/JsonRpcProviderWithRetries.d.ts

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

package/dist/evm/providers/JsonRpcProviderWithRetries.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcProviderWithRetries = void 0;
+const ethers_1 = require("ethers");
+const Utils_1 = require("../../utils/Utils");
+class JsonRpcProviderWithRetries extends ethers_1.JsonRpcProvider {
+    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.JsonRpcProviderWithRetries = JsonRpcProviderWithRetries;

package/dist/evm/providers/ReconnectingWebSocketProvider.d.ts

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

package/dist/evm/providers/ReconnectingWebSocketProvider.js

@@ -0,0 +1,77 @@
+"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.requestTimeoutSeconds = 10;
+        this.reconnectSeconds = 5;
+        this.pingIntervalSeconds = 30;
+        this.wsCtor = typeof (url) === "string" ? () => new WebSocket(url) : url;
+        this.connect();
+    }
+    connect() {
+        this.websocket = this.wsCtor();
+        this.websocket.onopen = () => {
+            this._connected();
+            this._start();
+            this.pingInterval = setInterval(() => {
+                this._send({ method: "eth_blockNumber", params: [], id: 1000000000, jsonrpc: "2.0" }).catch(e => {
+                    //Error
+                    if (e.code === "NETWORK_ERROR") {
+                        console.error("Websocket ping error: ", e);
+                        if (this.websocket != null) {
+                            this.websocket.close();
+                            this.disconnectedAndScheduleReconnect();
+                        }
+                    }
+                });
+            }, this.pingIntervalSeconds * 1000);
+        };
+        this.websocket.onerror = (err) => {
+            console.error(`Websocket connection error: `, err);
+            this.disconnectedAndScheduleReconnect();
+        };
+        this.websocket.onmessage = (message) => {
+            this._processMessage(message.data);
+        };
+        this.websocket.onclose = (event) => {
+            console.error(`Websocket connection closed: `, event);
+            this.disconnectedAndScheduleReconnect();
+        };
+    }
+    disconnectedAndScheduleReconnect() {
+        if (this.destroyed)
+            return;
+        if (this.websocket == null)
+            return;
+        this.websocket.onclose = null;
+        this.websocket.onerror = null;
+        this.websocket.onmessage = null;
+        this.websocket.onopen = null;
+        this.websocket = null;
+        if (this.pingInterval != null)
+            clearInterval(this.pingInterval);
+        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/providers/SocketProvider.d.ts

@@ -0,0 +1,111 @@
+/**
+ *  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;
+    requestTimeoutSeconds: number;
+    /**
+     *  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/providers/SocketProvider.js

@@ -0,0 +1,334 @@
+"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);
+        this.requestTimeoutSeconds = 10;
+        _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);
+        // Wait until the socket is connected before writing to it
+        await this._waitUntilReady();
+        if (!__classPrivateFieldGet(this, _SocketProvider_connected, "f") && payload.method === "eth_subscribe")
+            return Promise.reject((0, ethers_1.makeError)("WebSocket not connected!", "NETWORK_ERROR"));
+        // Prepare a promise to respond to
+        const promise = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                if (__classPrivateFieldGet(this, _SocketProvider_callbacks, "f").delete(payload.id)) {
+                    reject((0, ethers_1.makeError)("Request timed out!", "NETWORK_ERROR"));
+                }
+            }, this.requestTimeoutSeconds * 1000);
+            __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").set(payload.id, { payload, resolve, reject, timeout });
+        });
+        // Write the request to the socket
+        if (__classPrivateFieldGet(this, _SocketProvider_connected, "f"))
+            await this._write(JSON.stringify(payload));
+        return [await promise];
+    }
+    _connected() {
+        __classPrivateFieldSet(this, _SocketProvider_connected, true, "f");
+        this.resume();
+        this._forEachSubscriber(subscriber => subscriber.start());
+        __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").forEach(val => {
+            this._write(JSON.stringify(val.payload));
+        });
+    }
+    _disconnected() {
+        __classPrivateFieldSet(this, _SocketProvider_connected, false, "f");
+        this.pause(true);
+        __classPrivateFieldGet(this, _SocketProvider_callbacks, "f").forEach(val => {
+            clearTimeout(val.timeout);
+            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);
+            clearTimeout(callback.timeout);
+            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/providers/WebSocketProviderWithRetries.d.ts

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

package/dist/evm/providers/WebSocketProviderWithRetries.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketProviderWithRetries = void 0;
+const Utils_1 = require("../../utils/Utils");
+const ReconnectingWebSocketProvider_1 = require("./ReconnectingWebSocketProvider");
+class WebSocketProviderWithRetries extends ReconnectingWebSocketProvider_1.ReconnectingWebSocketProvider {
+    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/index.d.ts

@@ -38,6 +38,6 @@ export * from "./chains/citrea/CitreaChainType";
 export * from "./chains/citrea/CitreaFees";
 export * from "./chains/botanix/BotanixInitializer";
 export * from "./chains/botanix/BotanixChainType";
-export * from "./evm/JsonRpcProviderWithRetries";
-export * from "./evm/WebSocketProviderWithRetries";
-export * from "./evm/ReconnectingWebSocketProvider";
+export * from "./evm/providers/JsonRpcProviderWithRetries";
+export * from "./evm/providers/WebSocketProviderWithRetries";
+export * from "./evm/providers/ReconnectingWebSocketProvider";

package/dist/index.js

@@ -54,6 +54,6 @@ __exportStar(require("./chains/citrea/CitreaChainType"), exports);
 __exportStar(require("./chains/citrea/CitreaFees"), exports);
 __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);
+__exportStar(require("./evm/providers/JsonRpcProviderWithRetries"), exports);
+__exportStar(require("./evm/providers/WebSocketProviderWithRetries"), exports);
+__exportStar(require("./evm/providers/ReconnectingWebSocketProvider"), exports);

package/package.json

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

package/src/evm/events/EVMChainEventsBrowser.ts

@@ -82,13 +82,13 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
     }
 
     private addProcessedEvent(event: AtomiqTypedEvent) {
-        this.processedEvents[this.processedEventsIndex] = event.transactionHash+":"+event.transactionIndex;
+        this.processedEvents[this.processedEventsIndex] = event.transactionHash+":"+event.index;
         this.processedEventsIndex += 1;
         if(this.processedEventsIndex >= PROCESSED_EVENTS_BACKLOG) this.processedEventsIndex = 0;
     }
 
     private isEventProcessed(event: AtomiqTypedEvent): boolean {
-        return this.processedEvents.includes(event.transactionHash+":"+event.transactionIndex);
+        return this.processedEvents.includes(event.transactionHash+":"+event.index);
     }
 
     findInitSwapData(call: EVMTxTrace, escrowHash: string, claimHandler: IClaimHandler<any, any>): EVMSwapData {
@@ -255,7 +255,7 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
         currentBlock?: Block
     ) {
         for(let event of events) {
-            const eventIdentifier = event.transactionHash+":"+event.transactionIndex;
+            const eventIdentifier = event.transactionHash+":"+event.index;
 
             if(this.isEventProcessed(event)) {
                 this.logger.debug("processEvents(): skipping already processed event: "+eventIdentifier);
@@ -457,6 +457,7 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
         let processing = false;
         if(safeBlockTag!=="latest" && safeBlockTag!=="pending") await this.provider.on("block", this.blockListener = async (blockNumber: number) => {
             if(processing) return;
+            if(this.unconfirmedEventQueue.length===0) return;
             processing = true;
             try {
                 const latestSafeBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag);

package/src/evm/{JsonRpcProviderWithRetries.ts → providers/JsonRpcProviderWithRetries.ts}

@@ -1,6 +1,6 @@
 import {JsonRpcProvider, JsonRpcApiProviderOptions} from "ethers";
 import type {Networkish, FetchRequest} from "ethers";
-import {tryWithRetries} from "../utils/Utils";
+import {tryWithRetries} from "../../utils/Utils";
 
 
 export class JsonRpcProviderWithRetries extends JsonRpcProvider {

package/src/evm/{ReconnectingWebSocketProvider.ts → providers/ReconnectingWebSocketProvider.ts}

@@ -67,7 +67,6 @@ export class ReconnectingWebSocketProvider extends SocketProvider {
         this.websocket = null;
         if(this.pingInterval!=null) clearInterval(this.pingInterval);
 
-        //Fail all in-flight requests
         this._disconnected();
 
         console.error(`Retrying in ${this.reconnectSeconds} seconds...`);

package/src/evm/{SocketProvider.ts → providers/SocketProvider.ts}

@@ -184,7 +184,7 @@ export class SocketProvider extends JsonRpcApiProvider {
 
     requestTimeoutSeconds: number = 10;
 
-    #callbacks: Map<number, { payload: JsonRpcPayload, resolve: (r: any) => void, reject: (e: Error) => void }>;
+    #callbacks: Map<number, { payload: JsonRpcPayload, resolve: (r: any) => void, reject: (e: Error) => void, timeout: any }>;
 
     // Maps each filterId to its subscriber
     #subs: Map<number | string, SocketSubscriber>;
@@ -279,12 +279,12 @@ export class SocketProvider extends JsonRpcApiProvider {
 
         // Prepare a promise to respond to
         const promise = new Promise((resolve, reject) => {
-            this.#callbacks.set(payload.id, { payload, resolve, reject });
-            setTimeout(() => {
+            const timeout = setTimeout(() => {
                 if(this.#callbacks.delete(payload.id)) {
                     reject(makeError("Request timed out!", "NETWORK_ERROR"));
                 }
             }, this.requestTimeoutSeconds * 1000);
+            this.#callbacks.set(payload.id, { payload, resolve, reject, timeout });
         });
 
         // Write the request to the socket
@@ -308,6 +308,7 @@ export class SocketProvider extends JsonRpcApiProvider {
         this.pause(true);
 
         this.#callbacks.forEach(val => {
+            clearTimeout(val.timeout);
             val.reject(makeError("WebSocket disconnected!", "NETWORK_ERROR"))
         });
         this.#callbacks.clear();
@@ -331,6 +332,7 @@ export class SocketProvider extends JsonRpcApiProvider {
             }
             this.#callbacks.delete(result.id);
 
+            clearTimeout(callback.timeout);
             callback.resolve(result);
 
         } else if (result && (result as any).method === "eth_subscription") {

package/src/evm/{WebSocketProviderWithRetries.ts → providers/WebSocketProviderWithRetries.ts}

@@ -1,6 +1,6 @@
 import {JsonRpcApiProviderOptions} from "ethers";
 import type {Networkish} from "ethers";
-import {tryWithRetries} from "../utils/Utils";
+import {tryWithRetries} from "../../utils/Utils";
 import {ReconnectingWebSocketProvider} from "./ReconnectingWebSocketProvider";
 import type {WebSocketLike} from "ethers/lib.esm";
 

package/src/index.ts

@@ -47,6 +47,6 @@ export * from "./chains/citrea/CitreaFees";
 export * from "./chains/botanix/BotanixInitializer";
 export * from "./chains/botanix/BotanixChainType";
 
-export * from "./evm/JsonRpcProviderWithRetries";
-export * from "./evm/WebSocketProviderWithRetries";
-export * from "./evm/ReconnectingWebSocketProvider";
+export * from "./evm/providers/JsonRpcProviderWithRetries";
+export * from "./evm/providers/WebSocketProviderWithRetries";
+export * from "./evm/providers/ReconnectingWebSocketProvider";