@atomiqlabs/chain-evm 1.1.3 → 1.1.5

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

@@ -93,6 +93,7 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
     protected swapContractListener: (log: Log) => void;
     protected blockListener: (blockNumber: number) => Promise<void>;
     protected wsStarted: boolean;
+    protected addOrRemoveBlockListener(): Promise<void>;
     protected setupWebsocket(): Promise<void>;
     init(): Promise<void>;
     stop(): Promise<void>;

package/dist/evm/events/EVMChainEventsBrowser.js

@@ -326,9 +326,53 @@ class EVMChainEventsBrowser {
             return this.processEvents(events);
         }
         this.unconfirmedEventQueue.push(...events);
+        return this.addOrRemoveBlockListener();
+    }
+    async addOrRemoveBlockListener() {
+        if (this.unconfirmedEventQueue.length > 0) {
+            this.logger.debug(`addOrRemoveBlockListener(): Adding block listener, unconfirmed event count: ${this.unconfirmedEventQueue.length}`);
+            await this.provider.on("block", this.blockListener);
+        }
+        else {
+            this.logger.debug(`addOrRemoveBlockListener(): Removing block listener, unconfirmed event count: ${this.unconfirmedEventQueue.length}`);
+            await this.provider.off("block", this.blockListener);
+        }
     }
     async setupWebsocket() {
         this.wsStarted = true;
+        let processing = false;
+        this.blockListener = async (blockNumber) => {
+            if (processing)
+                return;
+            if (this.unconfirmedEventQueue.length === 0)
+                return;
+            processing = true;
+            try {
+                const latestSafeBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag);
+                const events = this.unconfirmedEventQueue.filter(event => {
+                    return event.blockNumber <= latestSafeBlock.number;
+                });
+                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);
+                        const index = this.unconfirmedEventQueue.indexOf(event);
+                        if (index !== -1)
+                            this.unconfirmedEventQueue.splice(index, 1);
+                    }
+                    else {
+                        //Block hash doesn't match
+                    }
+                }
+            }
+            catch (e) {
+                this.logger.error(`on('block'): Error when processing new block ${blockNumber}:`, e);
+            }
+            processing = false;
+            await this.addOrRemoveBlockListener();
+        };
         await this.provider.on(this.spvVaultContractLogFilter, this.spvVaultContractListener = (log) => {
             let events = this.evmSpvVaultContract.Events.toTypedEvents([log]);
             events = events.filter(val => !val.removed);
@@ -339,42 +383,6 @@ class EVMChainEventsBrowser {
             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;
-                if (this.unconfirmedEventQueue.length === 0)
-                    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() {
         if (this.provider.websocket != null) {

package/package.json

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

package/src/evm/events/EVMChainEventsBrowser.ts

@@ -439,45 +439,37 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
             return this.processEvents(events);
         }
         this.unconfirmedEventQueue.push(...events);
+        return this.addOrRemoveBlockListener();
     }
 
     protected spvVaultContractListener: (log: Log) => void;
     protected swapContractListener: (log: Log) => void;
     protected blockListener: (blockNumber: number) => Promise<void>;
-
     protected wsStarted: boolean = false;
 
+    protected async addOrRemoveBlockListener() {
+        if(this.unconfirmedEventQueue.length>0) {
+            this.logger.debug(`addOrRemoveBlockListener(): Adding block listener, unconfirmed event count: ${this.unconfirmedEventQueue.length}`);
+            await this.provider.on("block", this.blockListener);
+        } else {
+            this.logger.debug(`addOrRemoveBlockListener(): Removing block listener, unconfirmed event count: ${this.unconfirmedEventQueue.length}`);
+            await this.provider.off("block", this.blockListener);
+        }
+    }
+
     protected async setupWebsocket() {
         this.wsStarted = true;
 
-        await this.provider.on(this.spvVaultContractLogFilter, this.spvVaultContractListener = (log) => {
-            let events = this.evmSpvVaultContract.Events.toTypedEvents([log]);
-            events = events.filter(val => !val.removed);
-            this.handleWsEvents(events);
-        });
-
-        await this.provider.on(this.swapContractLogFilter, this.swapContractListener = (log) => {
-            let events = this.evmSwapContract.Events.toTypedEvents([log]);
-            events = events.filter(val => !val.removed && (val.eventName==="Initialize" || val.eventName==="Refund" || val.eventName==="Claim"));
-            this.handleWsEvents(events);
-        });
-
-        const safeBlockTag = this.chainInterface.config.safeBlockTag;
         let processing = false;
-        if(safeBlockTag!=="latest" && safeBlockTag!=="pending") await this.provider.on("block", this.blockListener = async (blockNumber: number) => {
+        this.blockListener = async (blockNumber: number) => {
             if(processing) return;
             if(this.unconfirmedEventQueue.length===0) return;
             processing = true;
             try {
                 const latestSafeBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag);
 
-                const events = [];
-                this.unconfirmedEventQueue = this.unconfirmedEventQueue.filter(event => {
-                    if(event.blockNumber <= latestSafeBlock.number) {
-                        events.push(event);
-                        return false;
-                    }
-                    return true;
+                const events = this.unconfirmedEventQueue.filter(event => {
+                    return event.blockNumber <= latestSafeBlock.number;
                 });
 
                 const blocks: {[blockNumber: number]: Block} = {};
@@ -486,6 +478,8 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
                     if(block.hash===event.blockHash) {
                         //Valid event
                         await this.processEvents([event], block);
+                        const index = this.unconfirmedEventQueue.indexOf(event);
+                        if(index!==-1) this.unconfirmedEventQueue.splice(index, 1);
                     } else {
                         //Block hash doesn't match
                     }
@@ -494,6 +488,19 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
                 this.logger.error(`on('block'): Error when processing new block ${blockNumber}:`, e);
             }
             processing = false;
+            await this.addOrRemoveBlockListener();
+        }
+
+        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);
         });
     }