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

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

@@ -10,4 +10,5 @@ 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";
-export type BotanixChainType = ChainType<"BOTANIX", never, EVMPreFetchVerification, EVMTx, EVMSigner, EVMSwapData, EVMSwapContract<"BOTANIX">, EVMChainInterface<"BOTANIX", 3636>, EVMChainEventsBrowser, EVMBtcRelay<any>, EVMSpvVaultData, EVMSpvWithdrawalData, EVMSpvVaultContract<"BOTANIX">>;
+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">>;

package/dist/chains/botanix/BotanixInitializer.js

@@ -12,6 +12,7 @@ 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
@@ -77,7 +78,9 @@ function initializeBotanix(options, bitcoinRpc, network) {
     const defaultContractAddresses = BotanixContractAddresses[options.chainType];
     const chainId = BotanixChainIds[options.chainType];
     const provider = typeof (options.rpcUrl) === "string" ?
-        new ethers_1.JsonRpcProvider(options.rpcUrl, { name: "Botanix", chainId }) :
+        (options.rpcUrl.startsWith("ws")
+            ? new ethers_1.WebSocketProvider(options.rpcUrl, { name: "Botanix", chainId })
+            : new ethers_1.JsonRpcProvider(options.rpcUrl, { name: "Botanix", chainId })) :
         options.rpcUrl;
     const Fees = options.fees ?? new EVMFees_1.EVMFees(provider, 2n * 1000000000n, 1000000n);
     const chainInterface = new EVMChainInterface_1.EVMChainInterface("BOTANIX", chainId, provider, {
@@ -96,7 +99,9 @@ function initializeBotanix(options, bitcoinRpc, network) {
         }
     });
     const spvVaultContract = new EVMSpvVaultContract_1.EVMSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract ?? defaultContractAddresses.spvVaultContract, options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight);
-    const chainEvents = new EVMChainEventsBrowser_1.EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
+    const chainEvents = provider instanceof ethers_1.WebSocketProvider ?
+        new EVMChainEventsBrowserWS_1.EVMChainEventsBrowserWS(chainInterface, swapContract, spvVaultContract) :
+        new EVMChainEventsBrowser_1.EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
     return {
         chainId: "BOTANIX",
         btcRelay,

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

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

package/dist/chains/citrea/CitreaInitializer.js

@@ -13,6 +13,7 @@ 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
@@ -83,7 +84,9 @@ function initializeCitrea(options, bitcoinRpc, network) {
     const defaultContractAddresses = CitreaContractAddresses[options.chainType];
     const chainId = CitreaChainIds[options.chainType];
     const provider = typeof (options.rpcUrl) === "string" ?
-        new ethers_1.JsonRpcProvider(options.rpcUrl, { name: "Citrea", chainId }) :
+        (options.rpcUrl.startsWith("ws")
+            ? new ethers_1.WebSocketProvider(options.rpcUrl, { name: "Citrea", chainId })
+            : new ethers_1.JsonRpcProvider(options.rpcUrl, { name: "Citrea", chainId })) :
         options.rpcUrl;
     const Fees = options.fees ?? new CitreaFees_1.CitreaFees(provider, 2n * 1000000000n, 1000000n);
     const chainInterface = new EVMChainInterface_1.EVMChainInterface("CITREA", chainId, provider, {
@@ -103,7 +106,9 @@ function initializeCitrea(options, bitcoinRpc, network) {
         }
     });
     const spvVaultContract = new CitreaSpvVaultContract_1.CitreaSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract ?? defaultContractAddresses.spvVaultContract, options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight);
-    const chainEvents = new EVMChainEventsBrowser_1.EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
+    const chainEvents = provider instanceof ethers_1.WebSocketProvider ?
+        new EVMChainEventsBrowserWS_1.EVMChainEventsBrowserWS(chainInterface, swapContract, spvVaultContract) :
+        new EVMChainEventsBrowser_1.EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
     return {
         chainId: "CITREA",
         btcRelay,

package/dist/evm/contract/modules/EVMContractEvents.d.ts

@@ -1,4 +1,4 @@
-import { BaseContract } from "ethers";
+import { BaseContract, Log } from "ethers";
 import { EVMEvents } from "../../chain/modules/EVMEvents";
 import { EVMContractBase } from "../EVMContractBase";
 import { EVMChainInterface } from "../../chain/EVMChainInterface";
@@ -7,7 +7,7 @@ export declare class EVMContractEvents<T extends BaseContract> extends EVMEvents
     readonly contract: EVMContractBase<T>;
     readonly baseContract: T;
     constructor(chainInterface: EVMChainInterface<any>, contract: EVMContractBase<T>);
-    private toTypedEvents;
+    toTypedEvents<TEventName extends keyof T["filters"]>(blockEvents: Log[]): TypedEventLog<T["filters"][TEventName]>[];
     private toFilter;
     /**
      * Returns the events occuring in a range of EVM blocks as identified by the contract and keys,

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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,264 @@
+"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;

package/dist/index.d.ts

@@ -14,6 +14,7 @@ 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";

package/dist/index.js

@@ -30,6 +30,7 @@ __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);

package/package.json

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

package/src/chains/botanix/BotanixChainType.ts

@@ -10,6 +10,7 @@ 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",
@@ -20,7 +21,7 @@ export type BotanixChainType = ChainType<
     EVMSwapData,
     EVMSwapContract<"BOTANIX">,
     EVMChainInterface<"BOTANIX", 3636>,
-    EVMChainEventsBrowser,
+    EVMChainEventsBrowser | EVMChainEventsBrowserWS,
     EVMBtcRelay<any>,
     EVMSpvVaultData,
     EVMSpvWithdrawalData,

package/src/chains/botanix/BotanixInitializer.ts

@@ -1,5 +1,5 @@
 import {BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType} from "@atomiqlabs/base";
-import {JsonRpcApiProvider, JsonRpcProvider} from "ethers";
+import {JsonRpcApiProvider, JsonRpcProvider, WebSocketProvider} from "ethers";
 import {EVMChainInterface, EVMRetryPolicy} from "../../evm/chain/EVMChainInterface";
 import {EVMFees} from "../../evm/chain/modules/EVMFees";
 import {EVMBtcRelay} from "../../evm/btcrelay/EVMBtcRelay";
@@ -10,6 +10,7 @@ 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,
@@ -109,7 +110,11 @@ export function initializeBotanix(
     const chainId = BotanixChainIds[options.chainType];
 
     const provider = typeof(options.rpcUrl)==="string" ?
-        new JsonRpcProvider(options.rpcUrl, {name: "Botanix", chainId}) :
+        (
+            options.rpcUrl.startsWith("ws")
+                ? new WebSocketProvider(options.rpcUrl, {name: "Botanix", chainId})
+                : new JsonRpcProvider(options.rpcUrl, {name: "Botanix", chainId})
+        ):
         options.rpcUrl;
 
     const Fees = options.fees ?? new EVMFees(provider, 2n * 1_000_000_000n, 1_000_000n);
@@ -142,7 +147,9 @@ export function initializeBotanix(
         options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight
     )
 
-    const chainEvents = new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
+    const chainEvents = provider instanceof WebSocketProvider ?
+        new EVMChainEventsBrowserWS(chainInterface, swapContract, spvVaultContract) :
+        new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
 
     return {
         chainId: "BOTANIX",

package/src/chains/citrea/CitreaChainType.ts

@@ -10,6 +10,7 @@ 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",
@@ -20,7 +21,7 @@ export type CitreaChainType = ChainType<
     EVMSwapData,
     CitreaSwapContract,
     EVMChainInterface<"CITREA", 5115>,
-    EVMChainEventsBrowser,
+    EVMChainEventsBrowser | EVMChainEventsBrowserWS,
     CitreaBtcRelay<any>,
     EVMSpvVaultData,
     EVMSpvWithdrawalData,

package/src/chains/citrea/CitreaInitializer.ts

@@ -1,11 +1,7 @@
 import {BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType} from "@atomiqlabs/base";
-import {JsonRpcApiProvider, JsonRpcProvider} from "ethers";
+import {JsonRpcApiProvider, JsonRpcProvider, WebSocketProvider} from "ethers";
 import {EVMChainInterface, EVMRetryPolicy} from "../../evm/chain/EVMChainInterface";
-import {EVMFees} from "../../evm/chain/modules/EVMFees";
 import {CitreaChainType} from "./CitreaChainType";
-import {EVMBtcRelay} from "../../evm/btcrelay/EVMBtcRelay";
-import {EVMSwapContract} from "../../evm/swaps/EVMSwapContract";
-import {EVMSpvVaultContract} from "../../evm/spv_swap/EVMSpvVaultContract";
 import {EVMChainEventsBrowser} from "../../evm/events/EVMChainEventsBrowser";
 import {EVMSwapData} from "../../evm/swaps/EVMSwapData";
 import {EVMSpvVaultData} from "../../evm/spv_swap/EVMSpvVaultData";
@@ -15,6 +11,7 @@ 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,
@@ -119,7 +116,11 @@ export function initializeCitrea(
     const chainId = CitreaChainIds[options.chainType];
 
     const provider = typeof(options.rpcUrl)==="string" ?
-        new JsonRpcProvider(options.rpcUrl, {name: "Citrea", chainId}) :
+        (
+            options.rpcUrl.startsWith("ws")
+                ? new WebSocketProvider(options.rpcUrl, {name: "Citrea", chainId})
+                : new JsonRpcProvider(options.rpcUrl, {name: "Citrea", chainId})
+        ):
         options.rpcUrl;
 
     const Fees = options.fees ?? new CitreaFees(provider, 2n * 1_000_000_000n, 1_000_000n);
@@ -153,7 +154,9 @@ export function initializeCitrea(
         options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight
     )
 
-    const chainEvents = new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
+    const chainEvents = provider instanceof WebSocketProvider ?
+        new EVMChainEventsBrowserWS(chainInterface, swapContract, spvVaultContract) :
+        new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
 
     return {
         chainId: "CITREA",

package/src/evm/contract/modules/EVMContractEvents.ts

@@ -15,7 +15,7 @@ export class EVMContractEvents<T extends BaseContract> extends EVMEvents {
         this.baseContract = contract.contract;
     }
 
-    private toTypedEvents<TEventName extends keyof T["filters"]>(blockEvents: Log[]): TypedEventLog<T["filters"][TEventName]>[] {
+    public toTypedEvents<TEventName extends keyof T["filters"]>(blockEvents: Log[]): TypedEventLog<T["filters"][TEventName]>[] {
         return blockEvents.map(log => this.contract.toTypedEvent<TEventName>(log));
     }
 

package/src/evm/events/EVMChainEventsBrowserWS.ts

@@ -0,0 +1,354 @@
+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;
+    }
+}

package/src/index.ts

@@ -17,6 +17,7 @@ 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";