@atomiqlabs/chain-evm 1.0.0-dev.62 → 1.0.0-dev.64

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

@@ -1,42 +1,42 @@
-import { BaseContract, Log } from "ethers";
-import { EVMEvents } from "../../chain/modules/EVMEvents";
-import { EVMContractBase } from "../EVMContractBase";
-import { EVMChainInterface } from "../../chain/EVMChainInterface";
-import { TypedEventLog } from "../../typechain/common";
-export declare class EVMContractEvents<T extends BaseContract> extends EVMEvents {
-    readonly contract: EVMContractBase<T>;
-    readonly baseContract: T;
-    constructor(chainInterface: EVMChainInterface<any>, contract: EVMContractBase<T>);
-    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,
-     *  returns pending events if no startHeight & endHeight is passed
-     *
-     * @param events
-     * @param keys
-     * @param startBlockHeight
-     * @param endBlockHeight
-     */
-    getContractBlockEvents<TEventName extends keyof T["filters"]>(events: TEventName[], keys: string[], startBlockHeight?: number, endBlockHeight?: number): Promise<TypedEventLog<T["filters"][TEventName]>[]>;
-    /**
-     * Runs a search backwards in time, processing the events for a specific topic public key
-     *
-     * @param events
-     * @param keys
-     * @param processor called for every event, should return a value if the correct event was found, or null
-     *  if the search should continue
-     * @param abortSignal
-     */
-    findInContractEvents<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: string[], processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>, abortSignal?: AbortSignal): Promise<TResult>;
-    /**
-     * Runs a search forwards in time, processing the events for a specific topic
-     *
-     * @param events
-     * @param keys
-     * @param processor called for every event, should return a value if the correct event was found, or null
-     *  if the search should continue
-     * @param abortSignal
-     */
-    findInContractEventsForward<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: string[], processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>, abortSignal?: AbortSignal): Promise<TResult>;
-}
+import { BaseContract, Log } from "ethers";
+import { EVMEvents } from "../../chain/modules/EVMEvents";
+import { EVMContractBase } from "../EVMContractBase";
+import { EVMChainInterface } from "../../chain/EVMChainInterface";
+import { TypedEventLog } from "../../typechain/common";
+export declare class EVMContractEvents<T extends BaseContract> extends EVMEvents {
+    readonly contract: EVMContractBase<T>;
+    readonly baseContract: T;
+    constructor(chainInterface: EVMChainInterface<any>, contract: EVMContractBase<T>);
+    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,
+     *  returns pending events if no startHeight & endHeight is passed
+     *
+     * @param events
+     * @param keys
+     * @param startBlockHeight
+     * @param endBlockHeight
+     */
+    getContractBlockEvents<TEventName extends keyof T["filters"]>(events: TEventName[], keys: string[], startBlockHeight?: number, endBlockHeight?: number): Promise<TypedEventLog<T["filters"][TEventName]>[]>;
+    /**
+     * Runs a search backwards in time, processing the events for a specific topic public key
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    findInContractEvents<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: string[], processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>, abortSignal?: AbortSignal): Promise<TResult>;
+    /**
+     * Runs a search forwards in time, processing the events for a specific topic
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    findInContractEventsForward<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: string[], processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>, abortSignal?: AbortSignal): Promise<TResult>;
+}

package/dist/evm/contract/modules/EVMContractEvents.js

@@ -1,75 +1,75 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMContractEvents = void 0;
-const EVMEvents_1 = require("../../chain/modules/EVMEvents");
-class EVMContractEvents extends EVMEvents_1.EVMEvents {
-    constructor(chainInterface, contract) {
-        super(chainInterface);
-        this.contract = contract;
-        this.baseContract = contract.contract;
-    }
-    toTypedEvents(blockEvents) {
-        return blockEvents.map(log => this.contract.toTypedEvent(log));
-    }
-    toFilter(events, keys) {
-        const filterArray = [];
-        filterArray.push(events.map(name => {
-            return this.baseContract.getEvent(name).fragment.topicHash;
-        }));
-        if (keys != null)
-            keys.forEach(key => filterArray.push(key));
-        return filterArray;
-    }
-    /**
-     * Returns the events occuring in a range of EVM blocks as identified by the contract and keys,
-     *  returns pending events if no startHeight & endHeight is passed
-     *
-     * @param events
-     * @param keys
-     * @param startBlockHeight
-     * @param endBlockHeight
-     */
-    async getContractBlockEvents(events, keys, startBlockHeight, endBlockHeight = startBlockHeight) {
-        const blockEvents = await super.getBlockEvents(await this.baseContract.getAddress(), this.toFilter(events, keys), startBlockHeight, endBlockHeight);
-        return this.toTypedEvents(blockEvents);
-    }
-    /**
-     * Runs a search backwards in time, processing the events for a specific topic public key
-     *
-     * @param events
-     * @param keys
-     * @param processor called for every event, should return a value if the correct event was found, or null
-     *  if the search should continue
-     * @param abortSignal
-     */
-    async findInContractEvents(events, keys, processor, abortSignal) {
-        return this.findInEvents(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events) => {
-            const parsedEvents = this.toTypedEvents(events);
-            for (let event of parsedEvents) {
-                const result = await processor(event);
-                if (result != null)
-                    return result;
-            }
-        }, abortSignal, this.contract.contractDeploymentHeight);
-    }
-    /**
-     * Runs a search forwards in time, processing the events for a specific topic
-     *
-     * @param events
-     * @param keys
-     * @param processor called for every event, should return a value if the correct event was found, or null
-     *  if the search should continue
-     * @param abortSignal
-     */
-    async findInContractEventsForward(events, keys, processor, abortSignal) {
-        return this.findInEventsForward(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events) => {
-            const parsedEvents = this.toTypedEvents(events);
-            for (let event of parsedEvents) {
-                const result = await processor(event);
-                if (result != null)
-                    return result;
-            }
-        }, abortSignal, this.contract.contractDeploymentHeight);
-    }
-}
-exports.EVMContractEvents = EVMContractEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMContractEvents = void 0;
+const EVMEvents_1 = require("../../chain/modules/EVMEvents");
+class EVMContractEvents extends EVMEvents_1.EVMEvents {
+    constructor(chainInterface, contract) {
+        super(chainInterface);
+        this.contract = contract;
+        this.baseContract = contract.contract;
+    }
+    toTypedEvents(blockEvents) {
+        return blockEvents.map(log => this.contract.toTypedEvent(log));
+    }
+    toFilter(events, keys) {
+        const filterArray = [];
+        filterArray.push(events.map(name => {
+            return this.baseContract.getEvent(name).fragment.topicHash;
+        }));
+        if (keys != null)
+            keys.forEach(key => filterArray.push(key));
+        return filterArray;
+    }
+    /**
+     * Returns the events occuring in a range of EVM blocks as identified by the contract and keys,
+     *  returns pending events if no startHeight & endHeight is passed
+     *
+     * @param events
+     * @param keys
+     * @param startBlockHeight
+     * @param endBlockHeight
+     */
+    async getContractBlockEvents(events, keys, startBlockHeight, endBlockHeight = startBlockHeight) {
+        const blockEvents = await super.getBlockEvents(await this.baseContract.getAddress(), this.toFilter(events, keys), startBlockHeight, endBlockHeight);
+        return this.toTypedEvents(blockEvents);
+    }
+    /**
+     * Runs a search backwards in time, processing the events for a specific topic public key
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    async findInContractEvents(events, keys, processor, abortSignal) {
+        return this.findInEvents(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events) => {
+            const parsedEvents = this.toTypedEvents(events);
+            for (let event of parsedEvents) {
+                const result = await processor(event);
+                if (result != null)
+                    return result;
+            }
+        }, abortSignal, this.contract.contractDeploymentHeight);
+    }
+    /**
+     * Runs a search forwards in time, processing the events for a specific topic
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    async findInContractEventsForward(events, keys, processor, abortSignal) {
+        return this.findInEventsForward(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events) => {
+            const parsedEvents = this.toTypedEvents(events);
+            for (let event of parsedEvents) {
+                const result = await processor(event);
+                if (result != null)
+                    return result;
+            }
+        }, abortSignal, this.contract.contractDeploymentHeight);
+    }
+}
+exports.EVMContractEvents = EVMContractEvents;

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

@@ -1,22 +1,22 @@
-import { EVMChainEventsBrowser } from "./EVMChainEventsBrowser";
-import { EVMChainInterface } from "../chain/EVMChainInterface";
-import { EVMSwapContract } from "../swaps/EVMSwapContract";
-import { EVMSpvVaultContract } from "../spv_swap/EVMSpvVaultContract";
-export declare class EVMChainEvents extends EVMChainEventsBrowser {
-    private readonly directory;
-    private readonly BLOCKHEIGHT_FILENAME;
-    constructor(directory: string, chainInterface: EVMChainInterface, evmSwapContract: EVMSwapContract, evmSpvVaultContract: EVMSpvVaultContract<any>, pollIntervalSeconds?: number);
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    private getLastEventData;
-    /**
-     * Saves last signature & slot to the filesystem
-     *
-     * @private
-     */
-    private saveLastEventData;
-    init(): Promise<void>;
-}
+import { EVMChainEventsBrowser } from "./EVMChainEventsBrowser";
+import { EVMChainInterface } from "../chain/EVMChainInterface";
+import { EVMSwapContract } from "../swaps/EVMSwapContract";
+import { EVMSpvVaultContract } from "../spv_swap/EVMSpvVaultContract";
+export declare class EVMChainEvents extends EVMChainEventsBrowser {
+    private readonly directory;
+    private readonly BLOCKHEIGHT_FILENAME;
+    constructor(directory: string, chainInterface: EVMChainInterface, evmSwapContract: EVMSwapContract, evmSpvVaultContract: EVMSpvVaultContract<any>, pollIntervalSeconds?: number);
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    private getLastEventData;
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    private saveLastEventData;
+    init(): Promise<void>;
+}

package/dist/evm/events/EVMChainEvents.js

@@ -1,69 +1,69 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMChainEvents = void 0;
-//@ts-ignore
-const fs = require("fs/promises");
-const EVMChainEventsBrowser_1 = require("./EVMChainEventsBrowser");
-class EVMChainEvents extends EVMChainEventsBrowser_1.EVMChainEventsBrowser {
-    constructor(directory, chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds) {
-        super(chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds);
-        this.BLOCKHEIGHT_FILENAME = "/" + chainInterface.chainId + "-blockheight.txt";
-        this.directory = directory;
-    }
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    async getLastEventData() {
-        try {
-            const txt = (await fs.readFile(this.directory + this.BLOCKHEIGHT_FILENAME)).toString();
-            const arr = txt.split(";");
-            return arr.map(val => {
-                const stateResult = val.split(",");
-                if (stateResult.length >= 3) {
-                    return {
-                        lastBlockNumber: parseInt(stateResult[0]),
-                        lastEvent: {
-                            blockHash: stateResult[1],
-                            logIndex: parseInt(stateResult[2])
-                        }
-                    };
-                }
-                else if (stateResult.length >= 1) {
-                    return {
-                        lastBlockNumber: parseInt(stateResult[0])
-                    };
-                }
-                else {
-                    return null;
-                }
-            });
-        }
-        catch (e) {
-            return null;
-        }
-    }
-    /**
-     * Saves last signature & slot to the filesystem
-     *
-     * @private
-     */
-    saveLastEventData(newState) {
-        return fs.writeFile(this.directory + this.BLOCKHEIGHT_FILENAME, newState.map(val => {
-            if (val.lastEvent == null) {
-                return val.lastBlockNumber.toString(10);
-            }
-            else {
-                return val.lastBlockNumber.toString(10) + "," + val.lastEvent.blockHash + "," + val.lastEvent.logIndex.toString(10);
-            }
-        }).join(";"));
-    }
-    async init() {
-        const lastState = await this.getLastEventData();
-        if (this.provider.websocket != null)
-            await this.setupWebsocket();
-        await this.setupPoll(lastState, (newState) => this.saveLastEventData(newState));
-    }
-}
-exports.EVMChainEvents = EVMChainEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMChainEvents = void 0;
+//@ts-ignore
+const fs = require("fs/promises");
+const EVMChainEventsBrowser_1 = require("./EVMChainEventsBrowser");
+class EVMChainEvents extends EVMChainEventsBrowser_1.EVMChainEventsBrowser {
+    constructor(directory, chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds) {
+        super(chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds);
+        this.BLOCKHEIGHT_FILENAME = "/" + chainInterface.chainId + "-blockheight.txt";
+        this.directory = directory;
+    }
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    async getLastEventData() {
+        try {
+            const txt = (await fs.readFile(this.directory + this.BLOCKHEIGHT_FILENAME)).toString();
+            const arr = txt.split(";");
+            return arr.map(val => {
+                const stateResult = val.split(",");
+                if (stateResult.length >= 3) {
+                    return {
+                        lastBlockNumber: parseInt(stateResult[0]),
+                        lastEvent: {
+                            blockHash: stateResult[1],
+                            logIndex: parseInt(stateResult[2])
+                        }
+                    };
+                }
+                else if (stateResult.length >= 1) {
+                    return {
+                        lastBlockNumber: parseInt(stateResult[0])
+                    };
+                }
+                else {
+                    return null;
+                }
+            });
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    saveLastEventData(newState) {
+        return fs.writeFile(this.directory + this.BLOCKHEIGHT_FILENAME, newState.map(val => {
+            if (val.lastEvent == null) {
+                return val.lastBlockNumber.toString(10);
+            }
+            else {
+                return val.lastBlockNumber.toString(10) + "," + val.lastEvent.blockHash + "," + val.lastEvent.logIndex.toString(10);
+            }
+        }).join(";"));
+    }
+    async init() {
+        const lastState = await this.getLastEventData();
+        if (this.provider.websocket != null)
+            await this.setupWebsocket();
+        await this.setupPoll(lastState, (newState) => this.saveLastEventData(newState));
+    }
+}
+exports.EVMChainEvents = EVMChainEvents;

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

@@ -1,102 +1,102 @@
-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, EventFilter, Log } 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";
-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
- *  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;
-    protected readonly evmSwapContract: EVMSwapContract;
-    protected readonly evmSpvVaultContract: EVMSpvVaultContract<any>;
-    protected readonly logger: import("../../utils/Utils").LoggerType;
-    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
-     *
-     * @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: (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;
-    }, lastBlockNumber?: number): Promise<[{
-        blockHash: string;
-        logIndex: number;
-    }, number]>;
-    protected checkEventsSpvVaults(currentBlock: Block, lastProcessedEvent?: {
-        blockHash: string;
-        logIndex: number;
-    }, lastBlockNumber?: number): Promise<[{
-        blockHash: string;
-        logIndex: number;
-    }, number]>;
-    protected checkEvents(lastState: EVMEventListenerState[]): Promise<EVMEventListenerState[]>;
-    /**
-     * Sets up event handlers listening for swap events over websocket
-     *
-     * @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 {};
+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, EventFilter, Log } 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";
+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
+ *  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;
+    protected readonly evmSwapContract: EVMSwapContract;
+    protected readonly evmSpvVaultContract: EVMSpvVaultContract<any>;
+    protected readonly logger: import("../../utils/Utils").LoggerType;
+    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
+     *
+     * @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: (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;
+    }, lastBlockNumber?: number): Promise<[{
+        blockHash: string;
+        logIndex: number;
+    }, number]>;
+    protected checkEventsSpvVaults(currentBlock: Block, lastProcessedEvent?: {
+        blockHash: string;
+        logIndex: number;
+    }, lastBlockNumber?: number): Promise<[{
+        blockHash: string;
+        logIndex: number;
+    }, number]>;
+    protected checkEvents(lastState: EVMEventListenerState[]): Promise<EVMEventListenerState[]>;
+    /**
+     * Sets up event handlers listening for swap events over websocket
+     *
+     * @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 {};