@atomiqlabs/chain-starknet 7.0.2 → 7.0.4

package/dist/starknet/chain/modules/StarknetFees.js

@@ -13,7 +13,7 @@ function starknetGasAdd(a, b) {
 }
 exports.starknetGasAdd = starknetGasAdd;
 class StarknetFees {
-    constructor(provider, maxFeeRate = { l1GasCost: 1000000000000000n, l2GasCost: 1000000000000000n, l1DataGasCost: 1000000000000000n } /*100 * 10000 GWei*/, feeMultiplier = 1.25, da) {
+    constructor(provider, maxFeeRate = { l1GasCost: 20000000000000000n, l2GasCost: 4000000000000000n, l1DataGasCost: 10000000000000000n }, feeMultiplier = 1.25, da) {
         this.logger = (0, Utils_1.getLogger)("StarknetFees: ");
         this.blockFeeCache = null;
         this.provider = provider;

package/dist/starknet/events/StarknetChainEvents.js

@@ -18,22 +18,21 @@ class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEven
     async getLastEventData() {
         try {
             const txt = (await fs.readFile(this.directory + BLOCKHEIGHT_FILENAME)).toString();
-            const arr = txt.split(";");
-            if (arr.length < 2)
-                return {
-                    blockNumber: parseInt(arr[0]),
-                    txHashes: null
-                };
-            return {
-                blockNumber: parseInt(arr[0]),
-                txHashes: arr.slice(1)
-            };
+            const arr = txt.split(",");
+            if (arr.length < 2) {
+                const blockNumber = parseInt(arr[0].split(";")[0]);
+                return [
+                    { lastBlockNumber: blockNumber, lastTxHash: null },
+                    { lastBlockNumber: blockNumber, lastTxHash: null }
+                ];
+            }
+            return arr.map(arrValue => {
+                const subArray = arrValue.split(";");
+                return { lastBlockNumber: parseInt(subArray[0]), lastTxHash: subArray[1] };
+            });
         }
         catch (e) {
-            return {
-                blockNumber: null,
-                txHashes: null
-            };
+            return [];
         }
     }
     /**
@@ -41,12 +40,12 @@ class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEven
      *
      * @private
      */
-    saveLastEventData(blockNumber, txHashes) {
-        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, blockNumber.toString() + ";" + txHashes.join(";"));
+    saveLastEventData(newState) {
+        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, newState.map(value => value.lastTxHash == null ? value.lastBlockNumber.toString(10) : value.lastBlockNumber.toString(10) + ";" + value.lastTxHash).join(","));
     }
     async init() {
-        const { blockNumber, txHashes } = await this.getLastEventData();
-        await this.setupPoll(blockNumber, txHashes, (blockNumber, txHashes) => this.saveLastEventData(blockNumber, txHashes));
+        const lastEventsState = await this.getLastEventData();
+        await this.setupPoll(lastEventsState, (newState) => this.saveLastEventData(newState));
     }
 }
 exports.StarknetChainEvents = StarknetChainEvents;

package/dist/starknet/events/StarknetChainEventsBrowser.d.ts

@@ -15,6 +15,10 @@ export type StarknetTraceCall = {
     entry_point_selector: string;
     calls: StarknetTraceCall[];
 };
+export type StarknetEventListenerState = {
+    lastBlockNumber: number;
+    lastTxHash?: string;
+};
 /**
  * Starknet 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
@@ -59,24 +63,21 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
      * @protected
      */
     protected processEvents(events: (StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize" | "escrow_manager::events::Refund" | "escrow_manager::events::Claim"> | StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Opened" | "spv_swap_vault::events::Deposited" | "spv_swap_vault::events::Fronted" | "spv_swap_vault::events::Claimed" | "spv_swap_vault::events::Closed">)[], currentBlockNumber: number, currentBlockTimestamp: number): Promise<void>;
-    protected checkEventsEcrowManager(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {
+    protected checkEventsEcrowManager(currentBlock: {
         timestamp: number;
         block_number: number;
-    }): Promise<string>;
-    protected checkEventsSpvVaults(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {
+    }, lastTxHash?: string, lastBlockNumber?: number): Promise<[string, number]>;
+    protected checkEventsSpvVaults(currentBlock: {
         timestamp: number;
         block_number: number;
-    }): Promise<string>;
-    protected checkEvents(lastBlockNumber: number, lastTxHashes: string[]): Promise<{
-        txHashes: string[];
-        blockNumber: number;
-    }>;
+    }, lastTxHash?: string, lastBlockNumber?: number): Promise<[string, number]>;
+    protected checkEvents(lastState: StarknetEventListenerState[]): Promise<StarknetEventListenerState[]>;
     /**
      * Sets up event handlers listening for swap events over websocket
      *
      * @protected
      */
-    protected setupPoll(lastBlockNumber?: number, lastTxHashes?: string[], saveLatestProcessedBlockNumber?: (blockNumber: number, lastTxHashes: string[]) => Promise<void>): Promise<void>;
+    protected setupPoll(lastState?: StarknetEventListenerState[], saveLatestProcessedBlockNumber?: (newState: StarknetEventListenerState[]) => Promise<void>): Promise<void>;
     init(): Promise<void>;
     stop(): Promise<void>;
     registerListener(cbk: EventListener<StarknetSwapData>): void;

package/dist/starknet/events/StarknetChainEventsBrowser.js

@@ -4,6 +4,7 @@ exports.StarknetChainEventsBrowser = void 0;
 const base_1 = require("@atomiqlabs/base");
 const Utils_1 = require("../../utils/Utils");
 const starknet_1 = require("starknet");
+const LOGS_SLIDING_WINDOW = 60;
 /**
  * Starknet 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
@@ -213,67 +214,87 @@ class StarknetChainEventsBrowser {
             await listener(parsedEvents);
         }
     }
-    async checkEventsEcrowManager(lastTxHash, lastBlockNumber, currentBlock) {
+    async checkEventsEcrowManager(currentBlock, lastTxHash, lastBlockNumber) {
         const currentBlockNumber = currentBlock.block_number;
         lastBlockNumber ?? (lastBlockNumber = currentBlockNumber);
+        if (currentBlockNumber < lastBlockNumber) {
+            this.logger.warn(`checkEventsEscrowManager(): Sanity check triggered - not processing events, currentBlock: ${currentBlockNumber}, lastBlock: ${lastBlockNumber}`);
+            return;
+        }
         // this.logger.debug("checkEvents(EscrowManager): Requesting logs: "+logStartHeight+"...pending");
         let events = await this.starknetSwapContract.Events.getContractBlockEvents(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], [], lastBlockNumber, null);
         if (lastTxHash != null) {
             const latestProcessedEventIndex = (0, Utils_1.findLastIndex)(events, val => val.txHash === lastTxHash);
             if (latestProcessedEventIndex !== -1) {
                 events.splice(0, latestProcessedEventIndex + 1);
-                // this.logger.debug("checkEvents(EscrowManager): Splicing processed events, resulting size: "+events.length);
+                this.logger.debug("checkEvents(EscrowManager): Splicing processed events, resulting size: " + events.length);
             }
         }
         if (events.length > 0) {
             await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp);
-            lastTxHash = events[events.length - 1].txHash;
+            const lastProcessed = events[events.length - 1];
+            lastTxHash = lastProcessed.txHash;
+            if (lastProcessed.blockNumber > lastBlockNumber)
+                lastBlockNumber = lastProcessed.blockNumber;
+        }
+        else if (currentBlockNumber - lastBlockNumber > LOGS_SLIDING_WINDOW) {
+            lastTxHash = null;
+            lastBlockNumber = currentBlockNumber - LOGS_SLIDING_WINDOW;
         }
-        return lastTxHash;
+        return [lastTxHash, lastBlockNumber];
     }
-    async checkEventsSpvVaults(lastTxHash, lastBlockNumber, currentBlock) {
+    async checkEventsSpvVaults(currentBlock, lastTxHash, lastBlockNumber) {
         const currentBlockNumber = currentBlock.block_number;
         lastBlockNumber ?? (lastBlockNumber = currentBlockNumber);
+        if (currentBlockNumber < lastBlockNumber) {
+            this.logger.warn(`checkEventsSpvVaults(): Sanity check triggered - not processing events, currentBlock: ${currentBlockNumber}, lastBlock: ${lastBlockNumber}`);
+            return;
+        }
         // this.logger.debug("checkEvents(SpvVaults): Requesting logs: "+logStartHeight+"...pending");
         let events = await this.starknetSpvVaultContract.Events.getContractBlockEvents(["spv_swap_vault::events::Opened", "spv_swap_vault::events::Deposited", "spv_swap_vault::events::Closed", "spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed"], [], lastBlockNumber, null);
         if (lastTxHash != null) {
             const latestProcessedEventIndex = (0, Utils_1.findLastIndex)(events, val => val.txHash === lastTxHash);
             if (latestProcessedEventIndex !== -1) {
                 events.splice(0, latestProcessedEventIndex + 1);
-                // this.logger.debug("checkEvents(SpvVaults): Splicing processed events, resulting size: "+events.length);
+                this.logger.debug("checkEvents(SpvVaults): Splicing processed events, resulting size: " + events.length);
             }
         }
         if (events.length > 0) {
             await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp);
-            lastTxHash = events[events.length - 1].txHash;
+            const lastProcessed = events[events.length - 1];
+            lastTxHash = lastProcessed.txHash;
+            if (lastProcessed.blockNumber > lastBlockNumber)
+                lastBlockNumber = lastProcessed.blockNumber;
         }
-        return lastTxHash;
+        else if (currentBlockNumber - lastBlockNumber > LOGS_SLIDING_WINDOW) {
+            lastTxHash = null;
+            lastBlockNumber = currentBlockNumber - LOGS_SLIDING_WINDOW;
+        }
+        return [lastTxHash, lastBlockNumber];
     }
-    async checkEvents(lastBlockNumber, lastTxHashes) {
-        lastTxHashes ?? (lastTxHashes = []);
+    async checkEvents(lastState) {
+        lastState ?? (lastState = []);
         const currentBlock = await this.provider.getBlockWithTxHashes(starknet_1.BlockTag.LATEST);
-        const currentBlockNumber = currentBlock.block_number;
-        lastTxHashes[0] = await this.checkEventsEcrowManager(lastTxHashes[0], lastBlockNumber, currentBlock);
-        lastTxHashes[1] = await this.checkEventsSpvVaults(lastTxHashes[1], lastBlockNumber, currentBlock);
-        return {
-            txHashes: lastTxHashes,
-            blockNumber: currentBlockNumber
-        };
+        const [lastEscrowTxHash, lastEscrowHeight] = await this.checkEventsEcrowManager(currentBlock, lastState?.[0]?.lastTxHash, lastState?.[0]?.lastBlockNumber);
+        const [lastSpvVaultTxHash, lastSpvVaultHeight] = await this.checkEventsSpvVaults(currentBlock, lastState?.[1]?.lastTxHash, lastState?.[1]?.lastBlockNumber);
+        return [
+            { lastBlockNumber: lastEscrowHeight, lastTxHash: lastEscrowTxHash },
+            { lastBlockNumber: lastSpvVaultHeight, lastTxHash: lastSpvVaultTxHash }
+        ];
     }
     /**
      * Sets up event handlers listening for swap events over websocket
      *
      * @protected
      */
-    async setupPoll(lastBlockNumber, lastTxHashes, saveLatestProcessedBlockNumber) {
+    async setupPoll(lastState, saveLatestProcessedBlockNumber) {
         this.stopped = false;
         let func;
         func = async () => {
-            await this.checkEvents(lastBlockNumber, lastTxHashes).then(({ blockNumber, txHashes }) => {
-                lastBlockNumber = blockNumber;
-                lastTxHashes = txHashes;
+            await this.checkEvents(lastState).then(newState => {
+                lastState = newState;
                 if (saveLatestProcessedBlockNumber != null)
-                    return saveLatestProcessedBlockNumber(blockNumber, lastTxHashes);
+                    return saveLatestProcessedBlockNumber(newState);
             }).catch(e => {
                 this.logger.error("setupPoll(): Failed to fetch starknet log: ", e);
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "7.0.2",
+  "version": "7.0.4",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/starknet/chain/modules/StarknetFees.ts

@@ -41,7 +41,7 @@ export class StarknetFees {
 
     constructor(
         provider: Provider,
-        maxFeeRate: StarknetFeeRate = {l1GasCost: 1_000_000_000_000_000n, l2GasCost: 1_000_000_000_000_000n, l1DataGasCost: 1_000_000_000_000_000n} /*100 * 10000 GWei*/,
+        maxFeeRate: StarknetFeeRate = {l1GasCost: 20_000_000_000_000_000n, l2GasCost: 4_000_000_000_000_000n, l1DataGasCost: 10_000_000_000_000_000n},
         feeMultiplier: number = 1.25,
         da?: {fee?: "L1" | "L2", nonce?: "L1" | "L2"}
     ) {

package/src/starknet/events/StarknetChainEvents.ts

@@ -1,4 +1,4 @@
-import {StarknetChainEventsBrowser} from "./StarknetChainEventsBrowser";
+import {StarknetChainEventsBrowser, StarknetEventListenerState} from "./StarknetChainEventsBrowser";
 //@ts-ignore
 import * as fs from "fs/promises";
 import {StarknetSwapContract} from "../swaps/StarknetSwapContract";
@@ -27,23 +27,24 @@ export class StarknetChainEvents extends StarknetChainEventsBrowser {
      *
      * @private
      */
-    private async getLastEventData(): Promise<{blockNumber: number, txHashes: string[]}> {
+    private async getLastEventData(): Promise<StarknetEventListenerState[]> {
         try {
             const txt: string = (await fs.readFile(this.directory+BLOCKHEIGHT_FILENAME)).toString();
-            const arr = txt.split(";");
-            if(arr.length<2) return {
-                blockNumber: parseInt(arr[0]),
-                txHashes: null
-            };
-            return {
-                blockNumber: parseInt(arr[0]),
-                txHashes: arr.slice(1)
-            };
+            const arr = txt.split(",");
+            if(arr.length<2) {
+                const blockNumber = parseInt(arr[0].split(";")[0]);
+                return [
+                    {lastBlockNumber: blockNumber, lastTxHash: null},
+                    {lastBlockNumber: blockNumber, lastTxHash: null}
+                ];
+            }
+
+            return arr.map(arrValue => {
+                const subArray = arrValue.split(";");
+                return {lastBlockNumber: parseInt(subArray[0]), lastTxHash: subArray[1]};
+            })
         } catch (e) {
-            return {
-                blockNumber: null,
-                txHashes: null
-            };
+            return [];
         }
     }
 
@@ -52,16 +53,15 @@ export class StarknetChainEvents extends StarknetChainEventsBrowser {
      *
      * @private
      */
-    private saveLastEventData(blockNumber: number, txHashes: string[]): Promise<void> {
-        return fs.writeFile(this.directory+BLOCKHEIGHT_FILENAME, blockNumber.toString()+";"+txHashes.join(";"));
+    private saveLastEventData(newState: StarknetEventListenerState[]): Promise<void> {
+        return fs.writeFile(this.directory+BLOCKHEIGHT_FILENAME, newState.map(value => value.lastTxHash==null ? value.lastBlockNumber.toString(10) : value.lastBlockNumber.toString(10)+";"+value.lastTxHash).join(","));
     }
 
     async init(): Promise<void> {
-        const {blockNumber, txHashes} = await this.getLastEventData();
+        const lastEventsState = await this.getLastEventData();
         await this.setupPoll(
-            blockNumber,
-            txHashes,
-            (blockNumber: number, txHashes: string[]) => this.saveLastEventData(blockNumber, txHashes)
+            lastEventsState,
+            (newState: StarknetEventListenerState[]) => this.saveLastEventData(newState)
         );
     }
 

package/src/starknet/events/StarknetChainEventsBrowser.ts

@@ -26,6 +26,8 @@ import {StarknetSpvVaultContract} from "../spv_swap/StarknetSpvVaultContract";
 import {StarknetChainInterface} from "../chain/StarknetChainInterface";
 import {SpvVaultContractAbiType} from "../spv_swap/SpvVaultContractAbi";
 
+const LOGS_SLIDING_WINDOW = 60;
+
 export type StarknetTraceCall = {
     calldata: string[],
     contract_address: string,
@@ -33,6 +35,8 @@ export type StarknetTraceCall = {
     calls: StarknetTraceCall[]
 };
 
+export type StarknetEventListenerState = {lastBlockNumber: number, lastTxHash?: string};
+
 /**
  * Starknet 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
@@ -306,9 +310,13 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
         }
     }
 
-    protected async checkEventsEcrowManager(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {timestamp: number, block_number: number}): Promise<string> {
-        const currentBlockNumber: number = (currentBlock as any).block_number;
+    protected async checkEventsEcrowManager(currentBlock: {timestamp: number, block_number: number}, lastTxHash?: string, lastBlockNumber?: number): Promise<[string, number]> {
+        const currentBlockNumber: number = currentBlock.block_number;
         lastBlockNumber ??= currentBlockNumber;
+        if(currentBlockNumber < lastBlockNumber) {
+            this.logger.warn(`checkEventsEscrowManager(): Sanity check triggered - not processing events, currentBlock: ${currentBlockNumber}, lastBlock: ${lastBlockNumber}`);
+            return;
+        }
         // this.logger.debug("checkEvents(EscrowManager): Requesting logs: "+logStartHeight+"...pending");
         let events = await this.starknetSwapContract.Events.getContractBlockEvents(
             ["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"],
@@ -320,19 +328,28 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
             const latestProcessedEventIndex = findLastIndex(events, val => val.txHash===lastTxHash);
             if(latestProcessedEventIndex!==-1) {
                 events.splice(0, latestProcessedEventIndex+1);
-                // this.logger.debug("checkEvents(EscrowManager): Splicing processed events, resulting size: "+events.length);
+                this.logger.debug("checkEvents(EscrowManager): Splicing processed events, resulting size: "+events.length);
             }
         }
         if(events.length>0) {
             await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp);
-            lastTxHash = events[events.length-1].txHash;
+            const lastProcessed = events[events.length-1];
+            lastTxHash = lastProcessed.txHash;
+            if(lastProcessed.blockNumber > lastBlockNumber) lastBlockNumber = lastProcessed.blockNumber;
+        } else if(currentBlockNumber - lastBlockNumber > LOGS_SLIDING_WINDOW) {
+            lastTxHash = null;
+            lastBlockNumber = currentBlockNumber - LOGS_SLIDING_WINDOW;
         }
-        return lastTxHash;
+        return [lastTxHash, lastBlockNumber];
     }
 
-    protected async checkEventsSpvVaults(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {timestamp: number, block_number: number}): Promise<string> {
-        const currentBlockNumber: number = (currentBlock as any).block_number;
+    protected async checkEventsSpvVaults(currentBlock: {timestamp: number, block_number: number}, lastTxHash?: string, lastBlockNumber?: number): Promise<[string, number]> {
+        const currentBlockNumber: number = currentBlock.block_number;
         lastBlockNumber ??= currentBlockNumber;
+        if(currentBlockNumber < lastBlockNumber) {
+            this.logger.warn(`checkEventsSpvVaults(): Sanity check triggered - not processing events, currentBlock: ${currentBlockNumber}, lastBlock: ${lastBlockNumber}`);
+            return;
+        }
         // this.logger.debug("checkEvents(SpvVaults): Requesting logs: "+logStartHeight+"...pending");
         let events = await this.starknetSpvVaultContract.Events.getContractBlockEvents(
             ["spv_swap_vault::events::Opened", "spv_swap_vault::events::Deposited", "spv_swap_vault::events::Closed", "spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed"],
@@ -344,29 +361,33 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
             const latestProcessedEventIndex = findLastIndex(events, val => val.txHash===lastTxHash);
             if(latestProcessedEventIndex!==-1) {
                 events.splice(0, latestProcessedEventIndex+1);
-                // this.logger.debug("checkEvents(SpvVaults): Splicing processed events, resulting size: "+events.length);
+                this.logger.debug("checkEvents(SpvVaults): Splicing processed events, resulting size: "+events.length);
             }
         }
         if(events.length>0) {
             await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp);
-            lastTxHash = events[events.length-1].txHash;
+            const lastProcessed = events[events.length-1];
+            lastTxHash = lastProcessed.txHash;
+            if(lastProcessed.blockNumber > lastBlockNumber) lastBlockNumber = lastProcessed.blockNumber;
+        } else if(currentBlockNumber - lastBlockNumber > LOGS_SLIDING_WINDOW) {
+            lastTxHash = null;
+            lastBlockNumber = currentBlockNumber - LOGS_SLIDING_WINDOW;
         }
-        return lastTxHash;
+        return [lastTxHash, lastBlockNumber];
     }
 
-    protected async checkEvents(lastBlockNumber: number, lastTxHashes: string[]): Promise<{txHashes: string[], blockNumber: number}> {
-        lastTxHashes ??= [];
+    protected async checkEvents(lastState: StarknetEventListenerState[]): Promise<StarknetEventListenerState[]> {
+        lastState ??= [];
 
         const currentBlock = await this.provider.getBlockWithTxHashes(BlockTag.LATEST);
-        const currentBlockNumber: number = currentBlock.block_number;
 
-        lastTxHashes[0] = await this.checkEventsEcrowManager(lastTxHashes[0], lastBlockNumber, currentBlock as any);
-        lastTxHashes[1] = await this.checkEventsSpvVaults(lastTxHashes[1], lastBlockNumber, currentBlock as any);
+        const [lastEscrowTxHash, lastEscrowHeight] = await this.checkEventsEcrowManager(currentBlock as any, lastState?.[0]?.lastTxHash, lastState?.[0]?.lastBlockNumber);
+        const [lastSpvVaultTxHash, lastSpvVaultHeight] = await this.checkEventsSpvVaults(currentBlock as any, lastState?.[1]?.lastTxHash, lastState?.[1]?.lastBlockNumber);
 
-        return {
-            txHashes: lastTxHashes,
-            blockNumber: currentBlockNumber
-        };
+        return [
+            {lastBlockNumber: lastEscrowHeight, lastTxHash: lastEscrowTxHash},
+            {lastBlockNumber: lastSpvVaultHeight, lastTxHash: lastSpvVaultTxHash}
+        ];
     }
 
     /**
@@ -375,17 +396,15 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
      * @protected
      */
     protected async setupPoll(
-        lastBlockNumber?: number,
-        lastTxHashes?: string[],
-        saveLatestProcessedBlockNumber?: (blockNumber: number, lastTxHashes: string[]) => Promise<void>
+        lastState?: StarknetEventListenerState[],
+        saveLatestProcessedBlockNumber?: (newState: StarknetEventListenerState[]) => Promise<void>
     ) {
         this.stopped = false;
         let func;
         func = async () => {
-            await this.checkEvents(lastBlockNumber, lastTxHashes).then(({blockNumber, txHashes}) => {
-                lastBlockNumber = blockNumber;
-                lastTxHashes = txHashes;
-                if(saveLatestProcessedBlockNumber!=null) return saveLatestProcessedBlockNumber(blockNumber, lastTxHashes);
+            await this.checkEvents(lastState).then(newState => {
+                lastState = newState;
+                if(saveLatestProcessedBlockNumber!=null) return saveLatestProcessedBlockNumber(newState);
             }).catch(e => {
                 this.logger.error("setupPoll(): Failed to fetch starknet log: ", e);
             });