@atomiqlabs/chain-evm 1.0.0-dev.50 → 1.0.0-dev.52

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,5 @@ export * from "./chains/citrea/CitreaFees";
 export * from "./chains/botanix/BotanixInitializer";
 export * from "./chains/botanix/BotanixChainType";
 export * from "./evm/JsonRpcProviderWithRetries";
+export * from "./evm/WebSocketProviderWithRetries";
+export * from "./evm/ReconnectingWebSocketProvider";

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,5 @@ __exportStar(require("./chains/citrea/CitreaFees"), exports);
 __exportStar(require("./chains/botanix/BotanixInitializer"), exports);
 __exportStar(require("./chains/botanix/BotanixChainType"), exports);
 __exportStar(require("./evm/JsonRpcProviderWithRetries"), exports);
+__exportStar(require("./evm/WebSocketProviderWithRetries"), exports);
+__exportStar(require("./evm/ReconnectingWebSocketProvider"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-evm",
-  "version": "1.0.0-dev.50",
+  "version": "1.0.0-dev.52",
   "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 as any).websocket!=null ?
-        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 as any).websocket!=null ?
-        new EVMChainEventsBrowserWS(chainInterface, swapContract, spvVaultContract) :
-        new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
+    const chainEvents = new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
 
     return {
         chainId: "CITREA",

package/src/evm/ReconnectingWebSocketProvider.ts

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