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

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

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

package/dist/chains/botanix/BotanixInitializer.js

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

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

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

package/dist/chains/citrea/CitreaInitializer.js

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

package/dist/evm/WebSocketProviderWithRetries.d.ts

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

package/dist/evm/WebSocketProviderWithRetries.js

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

package/dist/evm/events/EVMChainEvents.js

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

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

@@ -1,7 +1,7 @@
 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, JsonRpcApiProvider } from "ethers";
+import { Block, JsonRpcApiProvider, EventFilter, Log } from "ethers";
 import { EVMSwapContract } from "../swaps/EVMSwapContract";
 import { EVMSpvVaultContract } from "../spv_swap/EVMSpvVaultContract";
 import { EVMChainInterface } from "../chain/EVMChainInterface";
@@ -16,12 +16,16 @@ export type EVMEventListenerState = {
         logIndex: number;
     };
 };
+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 EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
+    private eventsProcessing;
+    private processedEvents;
+    private processedEventsIndex;
     protected readonly listeners: EventListener<EVMSwapData>[];
     protected readonly provider: JsonRpcApiProvider;
     protected readonly chainInterface: EVMChainInterface;
@@ -31,7 +35,12 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
     protected stopped: boolean;
     protected pollIntervalSeconds: number;
     private timeout;
+    protected readonly spvVaultContractLogFilter: EventFilter;
+    protected readonly swapContractLogFilter: EventFilter;
+    protected unconfirmedEventQueue: AtomiqTypedEvent[];
     constructor(chainInterface: EVMChainInterface, evmSwapContract: EVMSwapContract, evmSpvVaultContract: EVMSpvVaultContract<any>, pollIntervalSeconds?: number);
+    private addProcessedEvent;
+    private isEventProcessed;
     findInitSwapData(call: EVMTxTrace, escrowHash: string, claimHandler: IClaimHandler<any, any>): EVMSwapData;
     /**
      * Returns async getter for fetching on-demand initialize event swap data
@@ -57,7 +66,7 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
      * @param currentBlock
      * @protected
      */
-    protected processEvents(events: (TypedEventLog<EscrowManager["filters"]["Initialize" | "Refund" | "Claim"]> | TypedEventLog<SpvVaultManager["filters"]["Opened" | "Deposited" | "Fronted" | "Claimed" | "Closed"]>)[], currentBlock: Block): Promise<void>;
+    protected processEvents(events: (TypedEventLog<EscrowManager["filters"]["Initialize" | "Refund" | "Claim"]> | TypedEventLog<SpvVaultManager["filters"]["Opened" | "Deposited" | "Fronted" | "Claimed" | "Closed"]>)[], currentBlock?: Block): Promise<void>;
     protected checkEventsEcrowManager(currentBlock: Block, lastProcessedEvent?: {
         blockHash: string;
         logIndex: number;
@@ -79,8 +88,15 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
      * @protected
      */
     protected setupPoll(lastState?: EVMEventListenerState[], saveLatestProcessedBlockNumber?: (newState: EVMEventListenerState[]) => Promise<void>): Promise<void>;
+    protected handleWsEvents(events: AtomiqTypedEvent[]): Promise<void>;
+    protected spvVaultContractListener: (log: Log) => void;
+    protected swapContractListener: (log: Log) => void;
+    protected blockListener: (blockNumber: number) => Promise<void>;
+    protected wsStarted: boolean;
+    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/EVMChainEventsBrowser.js

@@ -7,6 +7,7 @@ const ethers_1 = require("ethers");
 const Utils_1 = require("../../utils/Utils");
 const EVMSpvVaultContract_1 = require("../spv_swap/EVMSpvVaultContract");
 const LOGS_SLIDING_WINDOW_LENGTH = 60;
+const PROCESSED_EVENTS_BACKLOG = 1000;
 /**
  * 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
@@ -14,13 +15,33 @@ const LOGS_SLIDING_WINDOW_LENGTH = 60;
  */
 class EVMChainEventsBrowser {
     constructor(chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds = 5) {
+        this.eventsProcessing = {};
+        this.processedEvents = [];
+        this.processedEventsIndex = 0;
         this.listeners = [];
         this.logger = (0, Utils_1.getLogger)("EVMChainEventsBrowser: ");
+        this.unconfirmedEventQueue = [];
+        this.wsStarted = false;
         this.chainInterface = chainInterface;
         this.provider = chainInterface.provider;
         this.evmSwapContract = evmSwapContract;
         this.evmSpvVaultContract = evmSpvVaultContract;
         this.pollIntervalSeconds = pollIntervalSeconds;
+        this.spvVaultContractLogFilter = {
+            address: this.evmSpvVaultContract.contractAddress
+        };
+        this.swapContractLogFilter = {
+            address: this.evmSwapContract.contractAddress
+        };
+    }
+    addProcessedEvent(event) {
+        this.processedEvents[this.processedEventsIndex] = event.transactionHash + ":" + event.transactionIndex;
+        this.processedEventsIndex += 1;
+        if (this.processedEventsIndex >= PROCESSED_EVENTS_BACKLOG)
+            this.processedEventsIndex = 0;
+    }
+    isEventProcessed(event) {
+        return this.processedEvents.includes(event.transactionHash + ":" + event.transactionIndex);
     }
     findInitSwapData(call, escrowHash, claimHandler) {
         if (call.to.toLowerCase() === this.evmSwapContract.contractAddress.toLowerCase()) {
@@ -141,8 +162,12 @@ class EVMChainEventsBrowser {
      * @protected
      */
     async processEvents(events, currentBlock) {
-        const parsedEvents = [];
         for (let event of events) {
+            const eventIdentifier = event.transactionHash + ":" + event.transactionIndex;
+            if (this.isEventProcessed(event)) {
+                this.logger.debug("processEvents(): skipping already processed event: " + eventIdentifier);
+                continue;
+            }
             let parsedEvent;
             switch (event.eventName) {
                 case "Claim":
@@ -170,16 +195,32 @@ class EVMChainEventsBrowser {
                     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);
+            if (this.eventsProcessing[eventIdentifier] != null) {
+                this.logger.debug("processEvents(): awaiting event that is currently processing: " + eventIdentifier);
+                await this.eventsProcessing[eventIdentifier];
+                continue;
+            }
+            const promise = (async () => {
+                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
+                };
+                for (let listener of this.listeners) {
+                    await listener([parsedEvent]);
+                }
+                this.addProcessedEvent(event);
+            })();
+            this.eventsProcessing[eventIdentifier] = promise;
+            try {
+                await promise;
+                delete this.eventsProcessing[eventIdentifier];
+            }
+            catch (e) {
+                delete this.eventsProcessing[eventIdentifier];
+                throw e;
+            }
         }
     }
     async checkEventsEcrowManager(currentBlock, lastProcessedEvent, lastBlockNumber) {
@@ -269,8 +310,67 @@ class EVMChainEventsBrowser {
         };
         await func();
     }
+    //Websocket
+    handleWsEvents(events) {
+        if (this.chainInterface.config.safeBlockTag === "latest" || this.chainInterface.config.safeBlockTag === "pending") {
+            return this.processEvents(events);
+        }
+        this.unconfirmedEventQueue.push(...events);
+    }
+    async setupWebsocket() {
+        this.wsStarted = true;
+        await this.provider.on(this.spvVaultContractLogFilter, this.spvVaultContractListener = (log) => {
+            let events = this.evmSpvVaultContract.Events.toTypedEvents([log]);
+            events = events.filter(val => !val.removed);
+            this.handleWsEvents(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.handleWsEvents(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() {
-        this.setupPoll();
+        if (this.provider.websocket != null) {
+            await this.setupWebsocket();
+        }
+        else {
+            await this.setupPoll();
+        }
         this.stopped = false;
         return Promise.resolve();
     }
@@ -278,6 +378,12 @@ class EVMChainEventsBrowser {
         this.stopped = true;
         if (this.timeout != null)
             clearTimeout(this.timeout);
+        if (this.wsStarted) {
+            await this.provider.off(this.spvVaultContractLogFilter, this.spvVaultContractListener);
+            await this.provider.off(this.swapContractLogFilter, this.swapContractListener);
+            await this.provider.off("block", this.blockListener);
+            this.wsStarted = false;
+        }
     }
     registerListener(cbk) {
         this.listeners.push(cbk);

package/dist/index.d.ts

@@ -14,7 +14,6 @@ export * from "./evm/contract/modules/EVMContractEvents";
 export * from "./evm/contract/EVMContractBase";
 export * from "./evm/contract/EVMContractModule";
 export * from "./evm/events/EVMChainEventsBrowser";
-export * from "./evm/events/EVMChainEventsBrowserWS";
 export * from "./evm/spv_swap/EVMSpvVaultContract";
 export * from "./evm/spv_swap/EVMSpvWithdrawalData";
 export * from "./evm/spv_swap/EVMSpvVaultData";
@@ -40,3 +39,4 @@ export * from "./chains/citrea/CitreaFees";
 export * from "./chains/botanix/BotanixInitializer";
 export * from "./chains/botanix/BotanixChainType";
 export * from "./evm/JsonRpcProviderWithRetries";
+export * from "./evm/WebSocketProviderWithRetries";

package/dist/index.js

@@ -30,7 +30,6 @@ __exportStar(require("./evm/contract/modules/EVMContractEvents"), exports);
 __exportStar(require("./evm/contract/EVMContractBase"), exports);
 __exportStar(require("./evm/contract/EVMContractModule"), exports);
 __exportStar(require("./evm/events/EVMChainEventsBrowser"), exports);
-__exportStar(require("./evm/events/EVMChainEventsBrowserWS"), exports);
 __exportStar(require("./evm/spv_swap/EVMSpvVaultContract"), exports);
 __exportStar(require("./evm/spv_swap/EVMSpvWithdrawalData"), exports);
 __exportStar(require("./evm/spv_swap/EVMSpvVaultData"), exports);
@@ -56,3 +55,4 @@ __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);

package/package.json

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

package/src/chains/botanix/BotanixChainType.ts

@@ -10,7 +10,6 @@ import { EVMSpvWithdrawalData } from "../../evm/spv_swap/EVMSpvWithdrawalData";
 import {EVMSwapContract} from "../../evm/swaps/EVMSwapContract";
 import {EVMBtcRelay} from "../../evm/btcrelay/EVMBtcRelay";
 import {EVMSpvVaultContract} from "../../evm/spv_swap/EVMSpvVaultContract";
-import {EVMChainEventsBrowserWS} from "../../evm/events/EVMChainEventsBrowserWS";
 
 export type BotanixChainType = ChainType<
     "BOTANIX",
@@ -21,7 +20,7 @@ export type BotanixChainType = ChainType<
     EVMSwapData,
     EVMSwapContract<"BOTANIX">,
     EVMChainInterface<"BOTANIX", 3636>,
-    EVMChainEventsBrowser | EVMChainEventsBrowserWS,
+    EVMChainEventsBrowser,
     EVMBtcRelay<any>,
     EVMSpvVaultData,
     EVMSpvWithdrawalData,

package/src/chains/botanix/BotanixInitializer.ts

@@ -10,7 +10,6 @@ import {EVMSwapData} from "../../evm/swaps/EVMSwapData";
 import {EVMSpvVaultData} from "../../evm/spv_swap/EVMSpvVaultData";
 import {EVMSpvWithdrawalData} from "../../evm/spv_swap/EVMSpvWithdrawalData";
 import {BotanixChainType} from "./BotanixChainType";
-import {EVMChainEventsBrowserWS} from "../../evm/events/EVMChainEventsBrowserWS";
 
 const BotanixChainIds = {
     MAINNET: null,
@@ -147,9 +146,7 @@ export function initializeBotanix(
         options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight
     )
 
-    const chainEvents = provider instanceof WebSocketProvider ?
-        new EVMChainEventsBrowserWS(chainInterface, swapContract, spvVaultContract) :
-        new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
+    const chainEvents = new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
 
     return {
         chainId: "BOTANIX",

package/src/chains/citrea/CitreaChainType.ts

@@ -10,7 +10,6 @@ import { EVMSpvWithdrawalData } from "../../evm/spv_swap/EVMSpvWithdrawalData";
 import {CitreaSwapContract} from "./CitreaSwapContract";
 import {CitreaBtcRelay} from "./CitreaBtcRelay";
 import {CitreaSpvVaultContract} from "./CitreaSpvVaultContract";
-import {EVMChainEventsBrowserWS} from "../../evm/events/EVMChainEventsBrowserWS";
 
 export type CitreaChainType = ChainType<
     "CITREA",
@@ -21,7 +20,7 @@ export type CitreaChainType = ChainType<
     EVMSwapData,
     CitreaSwapContract,
     EVMChainInterface<"CITREA", 5115>,
-    EVMChainEventsBrowser | EVMChainEventsBrowserWS,
+    EVMChainEventsBrowser,
     CitreaBtcRelay<any>,
     EVMSpvVaultData,
     EVMSpvWithdrawalData,

package/src/chains/citrea/CitreaInitializer.ts

@@ -11,7 +11,6 @@ import {CitreaBtcRelay} from "./CitreaBtcRelay";
 import {CitreaSwapContract} from "./CitreaSwapContract";
 import {CitreaTokens} from "./CitreaTokens";
 import {CitreaSpvVaultContract} from "./CitreaSpvVaultContract";
-import {EVMChainEventsBrowserWS} from "../../evm/events/EVMChainEventsBrowserWS";
 
 const CitreaChainIds = {
     MAINNET: null,
@@ -154,9 +153,7 @@ export function initializeCitrea(
         options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight
     )
 
-    const chainEvents = provider instanceof WebSocketProvider ?
-        new EVMChainEventsBrowserWS(chainInterface, swapContract, spvVaultContract) :
-        new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
+    const chainEvents = new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
 
     return {
         chainId: "CITREA",

package/src/evm/WebSocketProviderWithRetries.ts

@@ -0,0 +1,27 @@
+import {JsonRpcApiProviderOptions, WebSocketProvider} from "ethers";
+import type {Networkish, WebSocketCreator, WebSocketLike} from "ethers";
+import {tryWithRetries} from "../utils/Utils";
+
+
+export class WebSocketProviderWithRetries extends WebSocketProvider {
+
+    readonly retryPolicy?: {
+        maxRetries?: number, delay?: number, exponential?: boolean
+    };
+
+    constructor(url: string | WebSocketLike | WebSocketCreator, network?: Networkish, options?: JsonRpcApiProviderOptions & {
+        maxRetries?: number, delay?: number, exponential?: boolean
+    }) {
+        super(url, network, options);
+        this.retryPolicy = options;
+    }
+
+    send(method: string, params: Array<any> | Record<string, any>): Promise<any> {
+        return tryWithRetries(() => super.send(method, params), this.retryPolicy, e => {
+            return false;
+            // if(e?.error?.code!=null) return false; //Error returned by the RPC
+            // return true;
+        });
+    }
+
+}

package/src/evm/events/EVMChainEvents.ts

@@ -72,6 +72,7 @@ export class EVMChainEvents extends EVMChainEventsBrowser {
 
     async init(): Promise<void> {
         const lastState = await this.getLastEventData();
+        if((this.provider as any).websocket!=null) await this.setupWebsocket();
         await this.setupPoll(
             lastState,
             (newState: EVMEventListenerState[]) => this.saveLastEventData(newState)

package/src/evm/events/EVMChainEventsBrowser.ts

@@ -9,7 +9,7 @@ import {
 } from "@atomiqlabs/base";
 import {IClaimHandler} from "../swaps/handlers/claim/ClaimHandlers";
 import {EVMSwapData} from "../swaps/EVMSwapData";
-import {Block, hexlify, JsonRpcApiProvider} from "ethers";
+import {Block, hexlify, JsonRpcApiProvider, EventFilter, Log} from "ethers";
 import { EVMSwapContract } from "../swaps/EVMSwapContract";
 import {getLogger, onceAsync} from "../../utils/Utils";
 import {EVMSpvVaultContract, unpackOwnerAndVaultId} from "../spv_swap/EVMSpvVaultContract";
@@ -21,8 +21,15 @@ import {EVMTxTrace} from "../chain/modules/EVMTransactions";
 
 const LOGS_SLIDING_WINDOW_LENGTH = 60;
 
+const PROCESSED_EVENTS_BACKLOG = 1000;
+
 export type EVMEventListenerState = {lastBlockNumber: number, lastEvent?: {blockHash: string, logIndex: number}};
 
+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
@@ -30,6 +37,12 @@ export type EVMEventListenerState = {lastBlockNumber: number, lastEvent?: {block
  */
 export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
 
+    private eventsProcessing: {
+        [signature: string]: Promise<void>
+    } = {};
+    private processedEvents: string[] = [];
+    private processedEventsIndex: number = 0;
+
     protected readonly listeners: EventListener<EVMSwapData>[] = [];
     protected readonly provider: JsonRpcApiProvider;
     protected readonly chainInterface: EVMChainInterface;
@@ -42,6 +55,12 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
 
     private timeout: number;
 
+    //Websocket
+    protected readonly spvVaultContractLogFilter: EventFilter;
+    protected readonly swapContractLogFilter: EventFilter;
+
+    protected unconfirmedEventQueue: AtomiqTypedEvent[] = [];
+
     constructor(
         chainInterface: EVMChainInterface,
         evmSwapContract: EVMSwapContract,
@@ -53,6 +72,23 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
         this.evmSwapContract = evmSwapContract;
         this.evmSpvVaultContract = evmSpvVaultContract;
         this.pollIntervalSeconds = pollIntervalSeconds;
+
+        this.spvVaultContractLogFilter = {
+            address: this.evmSpvVaultContract.contractAddress
+        };
+        this.swapContractLogFilter = {
+            address: this.evmSwapContract.contractAddress
+        };
+    }
+
+    private addProcessedEvent(event: AtomiqTypedEvent) {
+        this.processedEvents[this.processedEventsIndex] = event.transactionHash+":"+event.transactionIndex;
+        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);
     }
 
     findInitSwapData(call: EVMTxTrace, escrowHash: string, claimHandler: IClaimHandler<any, any>): EVMSwapData {
@@ -216,11 +252,16 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
             TypedEventLog<EscrowManager["filters"]["Initialize" | "Refund" | "Claim"]> |
             TypedEventLog<SpvVaultManager["filters"]["Opened" | "Deposited" | "Fronted" | "Claimed" | "Closed"]>
         )[],
-        currentBlock: Block
+        currentBlock?: Block
     ) {
-        const parsedEvents: ChainEvent<EVMSwapData>[] = [];
-
         for(let event of events) {
+            const eventIdentifier = event.transactionHash+":"+event.transactionIndex;
+
+            if(this.isEventProcessed(event)) {
+                this.logger.debug("processEvents(): skipping already processed event: "+eventIdentifier);
+                continue;
+            }
+
             let parsedEvent: ChainEvent<EVMSwapData>;
             switch(event.eventName) {
                 case "Claim":
@@ -248,17 +289,33 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
                     parsedEvent = this.parseSpvCloseEvent(event as any);
                     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
-            } as any;
-            parsedEvents.push(parsedEvent);
-        }
 
-        for(let listener of this.listeners) {
-            await listener(parsedEvents);
+            if(this.eventsProcessing[eventIdentifier]!=null) {
+                this.logger.debug("processEvents(): awaiting event that is currently processing: "+eventIdentifier);
+                await this.eventsProcessing[eventIdentifier];
+                continue;
+            }
+
+            const promise = (async() => {
+                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
+                } as any;
+                for(let listener of this.listeners) {
+                    await listener([parsedEvent]);
+                }
+                this.addProcessedEvent(event);
+            })();
+            this.eventsProcessing[eventIdentifier] = promise;
+            try {
+                await promise;
+                delete this.eventsProcessing[eventIdentifier];
+            } catch (e) {
+                delete this.eventsProcessing[eventIdentifier];
+                throw e;
+            }
         }
     }
 
@@ -364,8 +421,78 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
         await func();
     }
 
+    //Websocket
+
+    protected handleWsEvents(
+        events : AtomiqTypedEvent[]
+    ): Promise<void> {
+        if(this.chainInterface.config.safeBlockTag==="latest" || this.chainInterface.config.safeBlockTag==="pending") {
+            return this.processEvents(events);
+        }
+        this.unconfirmedEventQueue.push(...events);
+    }
+
+    protected spvVaultContractListener: (log: Log) => void;
+    protected swapContractListener: (log: Log) => void;
+    protected blockListener: (blockNumber: number) => Promise<void>;
+
+    protected wsStarted: boolean = false;
+
+    protected async setupWebsocket() {
+        this.wsStarted = true;
+
+        await this.provider.on(this.spvVaultContractLogFilter, this.spvVaultContractListener = (log) => {
+            let events = this.evmSpvVaultContract.Events.toTypedEvents([log]);
+            events = events.filter(val => !val.removed);
+            this.handleWsEvents(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.handleWsEvents(events);
+        });
+
+        const safeBlockTag = this.chainInterface.config.safeBlockTag;
+        let processing = false;
+        if(safeBlockTag!=="latest" && safeBlockTag!=="pending") await this.provider.on("block", this.blockListener = async (blockNumber: number) => {
+            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: {[blockNumber: number]: Block} = {};
+                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(): Promise<void> {
-        this.setupPoll();
+        if((this.provider as any).websocket!=null) {
+            await this.setupWebsocket();
+        } else {
+            await this.setupPoll();
+        }
         this.stopped = false;
         return Promise.resolve();
     }
@@ -373,6 +500,12 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
     async stop(): Promise<void> {
         this.stopped = true;
         if(this.timeout!=null) clearTimeout(this.timeout);
+        if(this.wsStarted) {
+            await this.provider.off(this.spvVaultContractLogFilter, this.spvVaultContractListener);
+            await this.provider.off(this.swapContractLogFilter, this.swapContractListener);
+            await this.provider.off("block", this.blockListener);
+            this.wsStarted = false;
+        }
     }
 
     registerListener(cbk: EventListener<EVMSwapData>): void {

package/src/index.ts

@@ -17,7 +17,6 @@ export * from "./evm/contract/EVMContractBase";
 export * from "./evm/contract/EVMContractModule";
 
 export * from "./evm/events/EVMChainEventsBrowser";
-export * from "./evm/events/EVMChainEventsBrowserWS";
 
 export * from "./evm/spv_swap/EVMSpvVaultContract";
 export * from "./evm/spv_swap/EVMSpvWithdrawalData";
@@ -49,3 +48,4 @@ export * from "./chains/botanix/BotanixInitializer";
 export * from "./chains/botanix/BotanixChainType";
 
 export * from "./evm/JsonRpcProviderWithRetries";
+export * from "./evm/WebSocketProviderWithRetries";

package/src/evm/events/EVMChainEventsBrowserWS.ts

@@ -1,354 +0,0 @@
-import {
-    ChainEvent,
-    ChainEvents,
-    ChainSwapType,
-    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, hexlify, Log, WebSocketProvider} from "ethers";
-import { EVMSwapContract } from "../swaps/EVMSwapContract";
-import {getLogger, onceAsync} from "../../utils/Utils";
-import {EVMSpvVaultContract, unpackOwnerAndVaultId} 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 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 = getLogger("EVMChainEventsBrowser: ");
-
-    protected readonly spvVaultContractLogFilter: EventFilter;
-    protected readonly swapContractLogFilter: EventFilter;
-
-    protected unconfirmedEventQueue: AtomiqTypedEvent[] = [];
-
-    protected stopped: boolean;
-
-    constructor(
-        chainInterface: EVMChainInterface,
-        evmSwapContract: EVMSwapContract,
-        evmSpvVaultContract: EVMSpvVaultContract<any>
-    ) {
-        this.chainInterface = chainInterface;
-        this.provider = chainInterface.provider as WebSocketProvider;
-        this.evmSwapContract = evmSwapContract;
-        this.evmSpvVaultContract = evmSpvVaultContract;
-
-        this.spvVaultContractLogFilter = {
-            address: this.evmSpvVaultContract.contractAddress
-        };
-        this.swapContractLogFilter = {
-            address: this.evmSwapContract.contractAddress
-        };
-    }
-
-    findInitSwapData(call: EVMTxTrace, escrowHash: string, claimHandler: IClaimHandler<any, any>): EVMSwapData {
-        if(call.to.toLowerCase() === this.evmSwapContract.contractAddress.toLowerCase()) {
-            const result = this.evmSwapContract.parseCalldata<typeof this.evmSwapContract.contract.initialize>(call.input);
-            if(result!=null && result.name==="initialize") {
-                //Found, check correct escrow hash
-                const [escrowData, signature, timeout, extraData] = result.args;
-                const escrow = EVMSwapData.deserializeFromStruct(escrowData, claimHandler);
-                if("0x"+escrow.getEscrowHash()===escrowHash) {
-                    const extraDataHex = 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
-     */
-    private getSwapDataGetter(
-        event: TypedEventLog<EscrowManager["filters"]["Initialize"]>,
-        claimHandler: IClaimHandler<any, any>
-    ): () => Promise<EVMSwapData> {
-        return async () => {
-            const trace = await this.chainInterface.Transactions.traceTransaction(event.transactionHash);
-            if(trace==null) return null;
-            return this.findInitSwapData(trace, event.args.escrowHash, claimHandler);
-        }
-    }
-
-    protected parseInitializeEvent(
-        event: TypedEventLog<EscrowManager["filters"]["Initialize"]>
-    ): InitializeEvent<EVMSwapData> {
-        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: ChainSwapType = claimHandler.getType();
-
-        this.logger.debug("InitializeEvent escrowHash: "+escrowHash);
-        return new InitializeEvent<EVMSwapData>(
-            escrowHash,
-            swapType,
-            onceAsync<EVMSwapData>(this.getSwapDataGetter(event, claimHandler))
-        );
-    }
-
-    protected parseRefundEvent(
-        event: TypedEventLog<EscrowManager["filters"]["Refund"]>
-    ): RefundEvent<EVMSwapData> {
-        const escrowHash = event.args.escrowHash.substring(2);
-        this.logger.debug("RefundEvent escrowHash: "+escrowHash);
-        return new RefundEvent<EVMSwapData>(escrowHash);
-    }
-
-    protected parseClaimEvent(
-        event: TypedEventLog<EscrowManager["filters"]["Claim"]>
-    ): ClaimEvent<EVMSwapData> {
-        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 ClaimEvent<EVMSwapData>(escrowHash, witnessResult);
-    }
-
-    protected parseSpvOpenEvent(
-        event: TypedEventLog<SpvVaultManager["filters"]["Opened"]>
-    ): SpvVaultOpenEvent {
-        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 SpvVaultOpenEvent(owner, vaultId, btcTxId, vout);
-    }
-
-    protected parseSpvDepositEvent(
-        event: TypedEventLog<SpvVaultManager["filters"]["Deposited"]>
-    ): SpvVaultDepositEvent {
-        const [owner, vaultId] = 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 SpvVaultDepositEvent(owner, vaultId, amounts, depositCount);
-    }
-
-    protected parseSpvFrontEvent(
-        event: TypedEventLog<SpvVaultManager["filters"]["Fronted"]>
-    ): SpvVaultFrontEvent {
-        const [owner, vaultId] = 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 SpvVaultFrontEvent(owner, vaultId, btcTxId, recipient, executionHash, amounts, frontingAddress);
-    }
-
-    protected parseSpvClaimEvent(
-        event: TypedEventLog<SpvVaultManager["filters"]["Claimed"]>
-    ): SpvVaultClaimEvent {
-        const [owner, vaultId] = 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 SpvVaultClaimEvent(owner, vaultId, btcTxId, recipient, executionHash, amounts, caller, frontingAddress, withdrawCount);
-    }
-
-    protected parseSpvCloseEvent(
-        event: TypedEventLog<SpvVaultManager["filters"]["Closed"]>
-    ): SpvVaultCloseEvent {
-        const btcTxId = Buffer.from(event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
-
-        return new 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
-     */
-    protected async processEvents(
-        events: AtomiqTypedEvent[],
-        currentBlock?: Block
-    ) {
-        const parsedEvents: ChainEvent<EVMSwapData>[] = [];
-
-        for(let event of events) {
-            let parsedEvent: ChainEvent<EVMSwapData>;
-            switch(event.eventName) {
-                case "Claim":
-                    parsedEvent = this.parseClaimEvent(event as any);
-                    break;
-                case "Refund":
-                    parsedEvent = this.parseRefundEvent(event as any);
-                    break;
-                case "Initialize":
-                    parsedEvent = this.parseInitializeEvent(event as any);
-                    break;
-                case "Opened":
-                    parsedEvent = this.parseSpvOpenEvent(event as any);
-                    break;
-                case "Deposited":
-                    parsedEvent = this.parseSpvDepositEvent(event as any);
-                    break;
-                case "Fronted":
-                    parsedEvent = this.parseSpvFrontEvent(event as any);
-                    break;
-                case "Claimed":
-                    parsedEvent = this.parseSpvClaimEvent(event as any);
-                    break;
-                case "Closed":
-                    parsedEvent = this.parseSpvCloseEvent(event as any);
-                    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
-            } as any;
-            parsedEvents.push(parsedEvent);
-        }
-
-        for(let listener of this.listeners) {
-            await listener(parsedEvents);
-        }
-    }
-
-    protected handleEvents(
-        events : AtomiqTypedEvent[]
-    ): Promise<void> {
-        if(this.chainInterface.config.safeBlockTag==="latest" || this.chainInterface.config.safeBlockTag==="pending") {
-            return this.processEvents(events);
-        }
-        this.unconfirmedEventQueue.push(...events);
-    }
-
-    protected spvVaultContractListener: (log: Log) => void;
-    protected swapContractListener: (log: Log) => void;
-    protected blockListener: (blockNumber: number) => Promise<void>;
-
-    protected 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: number) => {
-            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: {[blockNumber: number]: Block} = {};
-                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(): Promise<void> {
-        await this.setupWebsocket();
-        this.stopped = false;
-    }
-
-    async stop(): Promise<void> {
-        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: EventListener<EVMSwapData>): void {
-        this.listeners.push(cbk);
-    }
-
-    unregisterListener(cbk: EventListener<EVMSwapData>): boolean {
-        const index = this.listeners.indexOf(cbk);
-        if(index>=0) {
-            this.listeners.splice(index, 1);
-            return true;
-        }
-        return false;
-    }
-}