@atomiqlabs/chain-evm 1.1.5 → 1.1.7

package/dist/chains/botanix/BotanixInitializer.js

@@ -90,7 +90,11 @@ function initializeBotanix(options, bitcoinRpc, network) {
         maxParallelLogRequests: options?.evmConfig?.maxParallelLogRequests ?? 5,
         maxParallelCalls: options?.evmConfig?.maxParallelCalls ?? 5,
         useAccessLists: options?.evmConfig?.useAccessLists,
-        defaultAccessListAddresses: options?.evmConfig?.defaultAccessListAddresses
+        defaultAccessListAddresses: options?.evmConfig?.defaultAccessListAddresses,
+        finalityCheckStrategy: {
+            type: "timer",
+            delayMs: 1000
+        }
     }, options.retryPolicy, Fees);
     const btcRelay = new EVMBtcRelay_1.EVMBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract ?? defaultContractAddresses.btcRelayContract, options.btcRelayDeploymentHeight ?? defaultContractAddresses.btcRelayDeploymentHeight);
     const swapContract = new EVMSwapContract_1.EVMSwapContract(chainInterface, btcRelay, options.swapContract ?? defaultContractAddresses.swapContract, {

package/dist/evm/chain/EVMChainInterface.d.ts

@@ -22,6 +22,10 @@ export type EVMConfiguration = {
     maxLogTopics: number;
     useAccessLists?: boolean;
     defaultAccessListAddresses?: string[];
+    finalityCheckStrategy?: {
+        type: "timer" | "blocks";
+        delayMs?: number;
+    };
 };
 export declare class EVMChainInterface<ChainId extends string = string> implements ChainInterface<EVMTx, EVMSigner, ChainId, Signer> {
     readonly chainId: ChainId;

package/dist/evm/chain/EVMChainInterface.js

@@ -14,7 +14,7 @@ const EVMSigner_1 = require("../wallet/EVMSigner");
 const EVMBrowserSigner_1 = require("../wallet/EVMBrowserSigner");
 class EVMChainInterface {
     constructor(chainId, evmChainId, provider, config, retryPolicy, evmFeeEstimator = new EVMFees_1.EVMFees(provider)) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         this.chainId = chainId;
         this.evmChainId = evmChainId;
         this.provider = provider;
@@ -22,6 +22,8 @@ class EVMChainInterface {
         this.config = config;
         (_a = this.config).safeBlockTag ?? (_a.safeBlockTag = "safe");
         (_b = this.config).finalizedBlockTag ?? (_b.finalizedBlockTag = "finalized");
+        (_c = this.config).finalityCheckStrategy ?? (_c.finalityCheckStrategy = { type: "timer" });
+        (_d = this.config.finalityCheckStrategy).delayMs ?? (_d.delayMs = 1000);
         this.logger = (0, Utils_1.getLogger)("EVMChainInterface(" + this.evmChainId + "): ");
         this.Fees = evmFeeEstimator;
         this.Tokens = new EVMTokens_1.EVMTokens(this);

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

@@ -38,6 +38,10 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
     protected readonly spvVaultContractLogFilter: EventFilter;
     protected readonly swapContractLogFilter: EventFilter;
     protected unconfirmedEventQueue: AtomiqTypedEvent[];
+    protected confirmedEventQueue: {
+        event: AtomiqTypedEvent;
+        block: Block;
+    }[];
     constructor(chainInterface: EVMChainInterface, evmSwapContract: EVMSwapContract, evmSpvVaultContract: EVMSpvVaultContract<any>, pollIntervalSeconds?: number);
     private addProcessedEvent;
     private isEventProcessed;
@@ -92,8 +96,11 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
     protected spvVaultContractListener: (log: Log) => void;
     protected swapContractListener: (log: Log) => void;
     protected blockListener: (blockNumber: number) => Promise<void>;
+    protected finalityCheckTimer: any;
     protected wsStarted: boolean;
+    protected checkUnconfirmedEventsFinality(): Promise<void>;
     protected addOrRemoveBlockListener(): Promise<void>;
+    protected startFinalityCheckTimer(): Promise<void>;
     protected setupWebsocket(): Promise<void>;
     init(): Promise<void>;
     stop(): Promise<void>;

package/dist/evm/events/EVMChainEventsBrowser.js

@@ -21,6 +21,7 @@ class EVMChainEventsBrowser {
         this.listeners = [];
         this.logger = (0, Utils_1.getLogger)("EVMChainEventsBrowser: ");
         this.unconfirmedEventQueue = [];
+        this.confirmedEventQueue = [];
         this.wsStarted = false;
         this.chainInterface = chainInterface;
         this.provider = chainInterface.provider;
@@ -209,8 +210,9 @@ class EVMChainEventsBrowser {
                     txId: event.transactionHash,
                     timestamp //Maybe deprecated
                 };
+                const eventsArr = [parsedEvent];
                 for (let listener of this.listeners) {
-                    await listener([parsedEvent]);
+                    await listener(eventsArr);
                 }
                 this.addProcessedEvent(event);
             })();
@@ -328,44 +330,76 @@ class EVMChainEventsBrowser {
         this.unconfirmedEventQueue.push(...events);
         return this.addOrRemoveBlockListener();
     }
-    async addOrRemoveBlockListener() {
+    async checkUnconfirmedEventsFinality() {
         if (this.unconfirmedEventQueue.length > 0) {
-            this.logger.debug(`addOrRemoveBlockListener(): Adding block listener, unconfirmed event count: ${this.unconfirmedEventQueue.length}`);
+            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
+                    const index = this.unconfirmedEventQueue.indexOf(event);
+                    if (index !== -1)
+                        this.unconfirmedEventQueue.splice(index, 1);
+                    this.confirmedEventQueue.push({ event, block });
+                }
+                else {
+                    //Block hash doesn't match
+                }
+            }
+        }
+        for (let confirmedEvent of this.confirmedEventQueue) {
+            await this.processEvents([confirmedEvent.event], confirmedEvent.block);
+            const index = this.confirmedEventQueue.indexOf(confirmedEvent);
+            if (index !== -1)
+                this.confirmedEventQueue.splice(index, 1);
+        }
+    }
+    async addOrRemoveBlockListener() {
+        if (this.chainInterface.config.finalityCheckStrategy.type !== "blocks")
+            return;
+        if (this.unconfirmedEventQueue.length > 0 || this.confirmedEventQueue.length > 0) {
+            this.logger.debug(`addOrRemoveBlockListener(): Adding block listener, unconfirmed/confirmed event count: ${this.unconfirmedEventQueue.length + this.confirmedEventQueue.length}`);
             await this.provider.on("block", this.blockListener);
         }
         else {
-            this.logger.debug(`addOrRemoveBlockListener(): Removing block listener, unconfirmed event count: ${this.unconfirmedEventQueue.length}`);
+            this.logger.debug(`addOrRemoveBlockListener(): Removing block listener, unconfirmed/confirmed event count: ${this.unconfirmedEventQueue.length + this.confirmedEventQueue.length}`);
             await this.provider.off("block", this.blockListener);
         }
     }
+    async startFinalityCheckTimer() {
+        let check;
+        check = async () => {
+            if (!this.wsStarted)
+                return;
+            if (this.unconfirmedEventQueue.length > 0 || this.confirmedEventQueue.length > 0) {
+                try {
+                    await this.checkUnconfirmedEventsFinality();
+                }
+                catch (e) {
+                    this.logger.error(`startFinalityCheckTimer(): Error when checking past events: `, e);
+                }
+            }
+            if (!this.wsStarted)
+                return;
+            this.finalityCheckTimer = setTimeout(check, this.chainInterface.config.finalityCheckStrategy.delayMs);
+        };
+        await check();
+    }
     async setupWebsocket() {
         this.wsStarted = true;
         let processing = false;
         this.blockListener = async (blockNumber) => {
             if (processing)
                 return;
-            if (this.unconfirmedEventQueue.length === 0)
+            if (this.unconfirmedEventQueue.length === 0 && this.confirmedEventQueue.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
-                    }
-                }
+                await this.checkUnconfirmedEventsFinality();
             }
             catch (e) {
                 this.logger.error(`on('block'): Error when processing new block ${blockNumber}:`, e);
@@ -373,6 +407,10 @@ class EVMChainEventsBrowser {
             processing = false;
             await this.addOrRemoveBlockListener();
         };
+        if (this.chainInterface.config.safeBlockTag === "safe" || this.chainInterface.config.safeBlockTag === "finalized") {
+            if (this.chainInterface.config.finalityCheckStrategy.type === "timer")
+                this.startFinalityCheckTimer();
+        }
         await this.provider.on(this.spvVaultContractLogFilter, this.spvVaultContractListener = (log) => {
             let events = this.evmSpvVaultContract.Events.toTypedEvents([log]);
             events = events.filter(val => !val.removed);
@@ -403,6 +441,7 @@ class EVMChainEventsBrowser {
             await this.provider.off(this.swapContractLogFilter, this.swapContractListener);
             await this.provider.off("block", this.blockListener);
             this.wsStarted = false;
+            clearTimeout(this.finalityCheckTimer);
         }
     }
     registerListener(cbk) {

package/package.json

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

package/src/chains/botanix/BotanixInitializer.ts

@@ -127,7 +127,11 @@ export function initializeBotanix(
         maxParallelLogRequests: options?.evmConfig?.maxParallelLogRequests ?? 5,
         maxParallelCalls: options?.evmConfig?.maxParallelCalls ?? 5,
         useAccessLists: options?.evmConfig?.useAccessLists,
-        defaultAccessListAddresses: options?.evmConfig?.defaultAccessListAddresses
+        defaultAccessListAddresses: options?.evmConfig?.defaultAccessListAddresses,
+        finalityCheckStrategy: {
+            type: "timer",
+            delayMs: 1000
+        }
     }, options.retryPolicy, Fees);
 
     const btcRelay = new EVMBtcRelay(

package/src/evm/chain/EVMChainInterface.ts

@@ -35,7 +35,12 @@ export type EVMConfiguration = {
     maxLogTopics: number,
 
     useAccessLists?: boolean,
-    defaultAccessListAddresses?: string[]
+    defaultAccessListAddresses?: string[],
+
+    finalityCheckStrategy?: {
+        type: "timer" | "blocks"
+        delayMs?: number
+    }
 };
 
 export class EVMChainInterface<ChainId extends string = string> implements ChainInterface<EVMTx, EVMSigner, ChainId, Signer> {
@@ -73,6 +78,8 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
         this.config = config;
         this.config.safeBlockTag ??= "safe";
         this.config.finalizedBlockTag ??= "finalized";
+        this.config.finalityCheckStrategy ??= {type: "timer"};
+        this.config.finalityCheckStrategy.delayMs ??= 1000;
 
         this.logger = getLogger("EVMChainInterface("+this.evmChainId+"): ");
 

package/src/evm/events/EVMChainEventsBrowser.ts

@@ -60,6 +60,7 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
     protected readonly swapContractLogFilter: EventFilter;
 
     protected unconfirmedEventQueue: AtomiqTypedEvent[] = [];
+    protected confirmedEventQueue: {event: AtomiqTypedEvent, block: Block}[] = [];
 
     constructor(
         chainInterface: EVMChainInterface,
@@ -304,8 +305,9 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
                     txId: event.transactionHash,
                     timestamp //Maybe deprecated
                 } as any;
+                const eventsArr = [parsedEvent];
                 for(let listener of this.listeners) {
-                    await listener([parsedEvent]);
+                    await listener(eventsArr);
                 }
                 this.addProcessedEvent(event);
             })();
@@ -445,45 +447,76 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
     protected spvVaultContractListener: (log: Log) => void;
     protected swapContractListener: (log: Log) => void;
     protected blockListener: (blockNumber: number) => Promise<void>;
+    protected finalityCheckTimer: any;
     protected wsStarted: boolean = false;
 
-    protected async addOrRemoveBlockListener() {
+    protected async checkUnconfirmedEventsFinality() {
         if(this.unconfirmedEventQueue.length>0) {
-            this.logger.debug(`addOrRemoveBlockListener(): Adding block listener, unconfirmed event count: ${this.unconfirmedEventQueue.length}`);
+            const latestSafeBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag);
+
+            const events = this.unconfirmedEventQueue.filter(event => {
+                return event.blockNumber <= latestSafeBlock.number;
+            });
+
+            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
+                    const index = this.unconfirmedEventQueue.indexOf(event);
+                    if(index!==-1) this.unconfirmedEventQueue.splice(index, 1);
+                    this.confirmedEventQueue.push({event, block});
+                } else {
+                    //Block hash doesn't match
+                }
+            }
+        }
+
+        for(let confirmedEvent of this.confirmedEventQueue) {
+            await this.processEvents([confirmedEvent.event], confirmedEvent.block);
+            const index = this.confirmedEventQueue.indexOf(confirmedEvent);
+            if(index!==-1) this.confirmedEventQueue.splice(index, 1);
+        }
+    }
+
+    protected async addOrRemoveBlockListener() {
+        if(this.chainInterface.config.finalityCheckStrategy.type!=="blocks") return;
+        if(this.unconfirmedEventQueue.length>0 || this.confirmedEventQueue.length>0) {
+            this.logger.debug(`addOrRemoveBlockListener(): Adding block listener, unconfirmed/confirmed event count: ${this.unconfirmedEventQueue.length + this.confirmedEventQueue.length}`);
             await this.provider.on("block", this.blockListener);
         } else {
-            this.logger.debug(`addOrRemoveBlockListener(): Removing block listener, unconfirmed event count: ${this.unconfirmedEventQueue.length}`);
+            this.logger.debug(`addOrRemoveBlockListener(): Removing block listener, unconfirmed/confirmed event count: ${this.unconfirmedEventQueue.length + this.confirmedEventQueue.length}`);
             await this.provider.off("block", this.blockListener);
         }
     }
 
+    protected async startFinalityCheckTimer() {
+        let check: () => Promise<void>;
+        check = async () => {
+            if(!this.wsStarted) return;
+            if(this.unconfirmedEventQueue.length>0 || this.confirmedEventQueue.length>0) {
+                try {
+                    await this.checkUnconfirmedEventsFinality();
+                } catch (e) {
+                    this.logger.error(`startFinalityCheckTimer(): Error when checking past events: `, e);
+                }
+            }
+            if(!this.wsStarted) return;
+            this.finalityCheckTimer = setTimeout(check, this.chainInterface.config.finalityCheckStrategy.delayMs);
+        };
+        await check();
+    }
+
     protected async setupWebsocket() {
         this.wsStarted = true;
 
         let processing = false;
         this.blockListener = async (blockNumber: number) => {
             if(processing) return;
-            if(this.unconfirmedEventQueue.length===0) return;
+            if(this.unconfirmedEventQueue.length===0 && this.confirmedEventQueue.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: {[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);
-                        const index = this.unconfirmedEventQueue.indexOf(event);
-                        if(index!==-1) this.unconfirmedEventQueue.splice(index, 1);
-                    } else {
-                        //Block hash doesn't match
-                    }
-                }
+                await this.checkUnconfirmedEventsFinality();
             } catch (e) {
                 this.logger.error(`on('block'): Error when processing new block ${blockNumber}:`, e);
             }
@@ -491,6 +524,10 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
             await this.addOrRemoveBlockListener();
         }
 
+        if(this.chainInterface.config.safeBlockTag==="safe" || this.chainInterface.config.safeBlockTag==="finalized") {
+            if(this.chainInterface.config.finalityCheckStrategy.type==="timer") this.startFinalityCheckTimer();
+        }
+
         await this.provider.on(this.spvVaultContractLogFilter, this.spvVaultContractListener = (log) => {
             let events = this.evmSpvVaultContract.Events.toTypedEvents([log]);
             events = events.filter(val => !val.removed);
@@ -522,6 +559,7 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
             await this.provider.off(this.swapContractLogFilter, this.swapContractListener);
             await this.provider.off("block", this.blockListener);
             this.wsStarted = false;
+            clearTimeout(this.finalityCheckTimer);
         }
     }