@atomiqlabs/chain-starknet 7.0.3 → 7.0.5

package/dist/starknet/StarknetInitializer.d.ts

@@ -1,4 +1,4 @@
-import { constants, Provider } from "starknet";
+import { constants, Provider, WebSocketChannel } from "starknet";
 import { StarknetFees } from "./chain/modules/StarknetFees";
 import { StarknetConfig, StarknetRetryPolicy } from "./chain/StarknetChainInterface";
 import { BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType } from "@atomiqlabs/base";
@@ -7,6 +7,7 @@ export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK" | "WBTC" | "TBTC"
 export declare const StarknetAssets: StarknetAssetsType;
 export type StarknetOptions = {
     rpcUrl: string | Provider;
+    wsUrl?: string | WebSocketChannel;
     retryPolicy?: StarknetRetryPolicy;
     chainId?: constants.StarknetChainId;
     swapContract?: string;

package/dist/starknet/StarknetInitializer.js

@@ -42,10 +42,15 @@ function initializeStarknet(options, bitcoinRpc, network) {
     const provider = typeof (options.rpcUrl) === "string" ?
         new RpcProviderWithRetries_1.RpcProviderWithRetries({ nodeUrl: options.rpcUrl }) :
         options.rpcUrl;
+    let wsChannel;
+    if (options.wsUrl != null)
+        wsChannel = typeof (options.wsUrl) === "string" ?
+            new starknet_1.WebSocketChannel({ nodeUrl: options.wsUrl, websocket: typeof window !== "undefined" && typeof window.WebSocket !== "undefined" ? window.WebSocket : require("ws") }) :
+            options.wsUrl;
     const Fees = options.fees ?? new StarknetFees_1.StarknetFees(provider);
     const chainId = options.chainId ??
         (network === base_1.BitcoinNetwork.MAINNET ? starknet_1.constants.StarknetChainId.SN_MAIN : starknet_1.constants.StarknetChainId.SN_SEPOLIA);
-    const chainInterface = new StarknetChainInterface_1.StarknetChainInterface(chainId, provider, options.retryPolicy, Fees, options.starknetConfig);
+    const chainInterface = new StarknetChainInterface_1.StarknetChainInterface(chainId, provider, wsChannel, options.retryPolicy, Fees, options.starknetConfig);
     const btcRelay = new StarknetBtcRelay_1.StarknetBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract);
     const swapContract = new StarknetSwapContract_1.StarknetSwapContract(chainInterface, btcRelay, options.swapContract, options.handlerContracts);
     const spvVaultContract = new StarknetSpvVaultContract_1.StarknetSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract);

package/dist/starknet/chain/StarknetChainInterface.d.ts

@@ -1,4 +1,4 @@
-import { Provider, constants, Account } from "starknet";
+import { Provider, constants, Account, WebSocketChannel } from "starknet";
 import { StarknetTransactions, StarknetTx } from "./modules/StarknetTransactions";
 import { StarknetFees } from "./modules/StarknetFees";
 import { StarknetTokens } from "./modules/StarknetTokens";
@@ -21,6 +21,7 @@ export type StarknetConfig = {
 };
 export declare class StarknetChainInterface implements ChainInterface<StarknetTx, StarknetSigner, "STARKNET", Account> {
     readonly chainId = "STARKNET";
+    readonly wsChannel?: WebSocketChannel;
     readonly provider: Provider;
     readonly retryPolicy: StarknetRetryPolicy;
     readonly starknetChainId: constants.StarknetChainId;
@@ -33,7 +34,7 @@ export declare class StarknetChainInterface implements ChainInterface<StarknetTx
     readonly Blocks: StarknetBlocks;
     protected readonly logger: import("../../utils/Utils").LoggerType;
     readonly config: StarknetConfig;
-    constructor(chainId: constants.StarknetChainId, provider: Provider, retryPolicy?: StarknetRetryPolicy, feeEstimator?: StarknetFees, options?: StarknetConfig);
+    constructor(chainId: constants.StarknetChainId, provider: Provider, wsChannel?: WebSocketChannel, retryPolicy?: StarknetRetryPolicy, feeEstimator?: StarknetFees, options?: StarknetConfig);
     getBalance(signer: string, tokenAddress: string): Promise<bigint>;
     getNativeCurrencyAddress(): string;
     isValidToken(tokenIdentifier: string): boolean;

package/dist/starknet/chain/StarknetChainInterface.js

@@ -16,7 +16,7 @@ const buffer_1 = require("buffer");
 const StarknetKeypairWallet_1 = require("../wallet/accounts/StarknetKeypairWallet");
 const StarknetBrowserSigner_1 = require("../wallet/StarknetBrowserSigner");
 class StarknetChainInterface {
-    constructor(chainId, provider, retryPolicy, feeEstimator = new StarknetFees_1.StarknetFees(provider), options) {
+    constructor(chainId, provider, wsChannel, retryPolicy, feeEstimator = new StarknetFees_1.StarknetFees(provider), options) {
         var _a, _b, _c, _d;
         this.chainId = "STARKNET";
         this.logger = (0, Utils_1.getLogger)("StarknetChainInterface: ");
@@ -28,6 +28,7 @@ class StarknetChainInterface {
         (_b = this.config).getLogChunkSize ?? (_b.getLogChunkSize = 100);
         (_c = this.config).maxGetLogKeys ?? (_c.maxGetLogKeys = 64);
         (_d = this.config).maxParallelCalls ?? (_d.maxParallelCalls = 10);
+        this.wsChannel = wsChannel;
         this.Fees = feeEstimator;
         this.Tokens = new StarknetTokens_1.StarknetTokens(this);
         this.Transactions = new StarknetTransactions_1.StarknetTransactions(this);

package/dist/starknet/contract/modules/StarknetContractEvents.d.ts

@@ -1,6 +1,6 @@
 import { Abi } from "abi-wan-kanabi";
 import { EventToPrimitiveType, ExtractAbiEventNames } from "abi-wan-kanabi/dist/kanabi";
-import { StarknetEvents } from "../../chain/modules/StarknetEvents";
+import { StarknetEvent, StarknetEvents } from "../../chain/modules/StarknetEvents";
 import { StarknetContractBase } from "../StarknetContractBase";
 import { StarknetChainInterface } from "../../chain/StarknetChainInterface";
 export type StarknetAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = {
@@ -16,8 +16,8 @@ export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEv
     readonly contract: StarknetContractBase<TAbi>;
     readonly abi: TAbi;
     constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi);
-    private toStarknetAbiEvents;
-    private toFilter;
+    toStarknetAbiEvents<T extends ExtractAbiEventNames<TAbi>>(blockEvents: StarknetEvent[]): StarknetAbiEvent<TAbi, T>[];
+    toFilter<T extends ExtractAbiEventNames<TAbi>>(events: T[], keys: (string | string[])[]): string[][];
     /**
      * Returns the events occuring in a range of starknet block as identified by the contract and keys,
      *  returns pending events if no startHeight & endHeight is passed

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,14 @@ 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();
+        if (this.wsChannel != null)
+            await this.setupWebsocket();
+        await this.setupPoll(lastEventsState, (newState) => this.saveLastEventData(newState));
     }
 }
 exports.StarknetChainEvents = StarknetChainEvents;

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

@@ -1,7 +1,7 @@
 import { ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent, SpvVaultClaimEvent, SpvVaultCloseEvent, SpvVaultDepositEvent, SpvVaultFrontEvent, SpvVaultOpenEvent } from "@atomiqlabs/base";
 import { StarknetSwapData } from "../swaps/StarknetSwapData";
 import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
-import { BigNumberish, Provider } from "starknet";
+import { BigNumberish, Provider, SubscriptionStarknetEventsEvent, WebSocketChannel } from "starknet";
 import { StarknetAbiEvent } from "../contract/modules/StarknetContractEvents";
 import { EscrowManagerAbiType } from "../swaps/EscrowManagerAbi";
 import { ExtractAbiFunctionNames } from "abi-wan-kanabi/dist/kanabi";
@@ -15,23 +15,36 @@ 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
  *  rely purely on events
  */
 export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData> {
+    private eventsProcessing;
+    private processedEvents;
+    protected readonly Chain: StarknetChainInterface;
     protected readonly listeners: EventListener<StarknetSwapData>[];
+    protected readonly wsChannel?: WebSocketChannel;
     protected readonly provider: Provider;
     protected readonly starknetSwapContract: StarknetSwapContract;
     protected readonly starknetSpvVaultContract: StarknetSpvVaultContract;
     protected readonly logger: import("../../utils/Utils").LoggerType;
+    protected escrowContractSubscription: SubscriptionStarknetEventsEvent;
+    protected spvVaultContractSubscription: SubscriptionStarknetEventsEvent;
     protected initFunctionName: ExtractAbiFunctionNames<EscrowManagerAbiType>;
     protected initEntryPointSelector: bigint;
     protected stopped: boolean;
     protected pollIntervalSeconds: number;
     private timeout;
     constructor(chainInterface: StarknetChainInterface, starknetSwapContract: StarknetSwapContract, starknetSpvVaultContract: StarknetSpvVaultContract, pollIntervalSeconds?: number);
+    private getEventFingerprint;
+    private addProcessedEvent;
+    private isEventProcessed;
     findInitSwapData(call: StarknetTraceCall, escrowHash: BigNumberish, claimHandler: IClaimHandler<any, any>): StarknetSwapData;
     /**
      * Returns async getter for fetching on-demand initialize event swap data
@@ -58,25 +71,24 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
      * @param currentBlockTimestamp
      * @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 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(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>;
+    protected wsStarted: boolean;
+    protected setupWebsocket(): Promise<void>;
     init(): Promise<void>;
     stop(): Promise<void>;
     registerListener(cbk: EventListener<StarknetSwapData>): void;

package/dist/starknet/events/StarknetChainEventsBrowser.js

@@ -4,6 +4,10 @@ exports.StarknetChainEventsBrowser = void 0;
 const base_1 = require("@atomiqlabs/base");
 const Utils_1 = require("../../utils/Utils");
 const starknet_1 = require("starknet");
+const sha2_1 = require("@noble/hashes/sha2");
+const buffer_1 = require("buffer");
+const PROCESSED_EVENTS_BACKLOG = 5000;
+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
@@ -11,15 +15,37 @@ const starknet_1 = require("starknet");
  */
 class StarknetChainEventsBrowser {
     constructor(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds = 5) {
+        this.eventsProcessing = {};
+        this.processedEvents = new Set();
         this.listeners = [];
         this.logger = (0, Utils_1.getLogger)("StarknetChainEventsBrowser: ");
         this.initFunctionName = "initialize";
         this.initEntryPointSelector = BigInt(starknet_1.hash.starknetKeccak(this.initFunctionName));
+        this.wsStarted = false;
+        this.Chain = chainInterface;
+        this.wsChannel = chainInterface.wsChannel;
         this.provider = chainInterface.provider;
         this.starknetSwapContract = starknetSwapContract;
         this.starknetSpvVaultContract = starknetSpvVaultContract;
         this.pollIntervalSeconds = pollIntervalSeconds;
     }
+    getEventFingerprint(event) {
+        const eventData = buffer_1.Buffer.concat([
+            ...event.keys.map(value => (0, Utils_1.bigNumberishToBuffer)(value, 64)),
+            ...event.data.map(value => (0, Utils_1.bigNumberishToBuffer)(value, 64))
+        ]);
+        const fingerprint = buffer_1.Buffer.from((0, sha2_1.sha256)(eventData));
+        return event.txHash + ":" + fingerprint.toString("hex");
+    }
+    addProcessedEvent(event) {
+        this.processedEvents.add(this.getEventFingerprint(event));
+        if (this.processedEvents.size > PROCESSED_EVENTS_BACKLOG)
+            this.processedEvents.delete(this.processedEvents.keys().next().value);
+    }
+    isEventProcessed(eventOrFingerprint) {
+        const eventFingerprint = typeof (eventOrFingerprint) === "string" ? eventOrFingerprint : this.getEventFingerprint(eventOrFingerprint);
+        return this.processedEvents.has(eventFingerprint);
+    }
     findInitSwapData(call, escrowHash, claimHandler) {
         if (BigInt(call.contract_address) === BigInt(this.starknetSwapContract.contract.address) &&
             BigInt(call.entry_point_selector) === this.initEntryPointSelector) {
@@ -164,11 +190,15 @@ class StarknetChainEventsBrowser {
             if (blockNumber === currentBlockNumber)
                 return currentBlockTimestamp;
             const blockNumberString = blockNumber.toString();
-            blockTimestampsCache[blockNumberString] ?? (blockTimestampsCache[blockNumberString] = (await this.provider.getBlockWithTxHashes(blockNumber)).timestamp);
+            blockTimestampsCache[blockNumberString] ?? (blockTimestampsCache[blockNumberString] = await this.Chain.Blocks.getBlockTime(blockNumber));
             return blockTimestampsCache[blockNumberString];
         };
-        const parsedEvents = [];
         for (let event of events) {
+            const eventIdentifier = this.getEventFingerprint(event);
+            if (this.isEventProcessed(eventIdentifier)) {
+                this.logger.debug("processEvents(): skipping already processed event: " + eventIdentifier);
+                continue;
+            }
             let parsedEvent;
             switch (event.name) {
                 case "escrow_manager::events::Claim":
@@ -196,84 +226,119 @@ class StarknetChainEventsBrowser {
                     parsedEvent = this.parseSpvCloseEvent(event);
                     break;
             }
-            if (parsedEvent == null)
+            if (this.eventsProcessing[eventIdentifier] != null) {
+                this.logger.debug("processEvents(): awaiting event that is currently processing: " + eventIdentifier);
+                await this.eventsProcessing[eventIdentifier];
                 continue;
-            //We are not trusting pre-confs for events, so this shall never happen
-            if (event.blockNumber == null)
-                throw new Error("Event block number cannot be null!");
-            const timestamp = await getBlockTimestamp(event.blockNumber);
-            parsedEvent.meta = {
-                blockTime: timestamp,
-                txId: event.txHash,
-                timestamp //Maybe deprecated
-            };
-            parsedEvents.push(parsedEvent);
-        }
-        for (let listener of this.listeners) {
-            await listener(parsedEvents);
+            }
+            const promise = (async () => {
+                if (parsedEvent == null)
+                    return;
+                //We are not trusting pre-confs for events, so this shall never happen
+                if (event.blockNumber == null)
+                    throw new Error("Event block number cannot be null!");
+                const timestamp = await getBlockTimestamp(event.blockNumber);
+                parsedEvent.meta = {
+                    blockTime: timestamp,
+                    txId: event.txHash,
+                    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(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 = []);
-        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
-        };
+    async checkEvents(lastState) {
+        lastState ?? (lastState = []);
+        const currentBlock = await this.Chain.Blocks.getBlock(starknet_1.BlockTag.LATEST);
+        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) {
-        this.stopped = false;
+    async setupPoll(lastState, saveLatestProcessedBlockNumber) {
         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);
             });
@@ -283,14 +348,49 @@ class StarknetChainEventsBrowser {
         };
         await func();
     }
-    init() {
-        this.setupPoll();
-        return Promise.resolve();
+    async setupWebsocket() {
+        this.wsStarted = true;
+        const [escrowContractSubscription, spvVaultContractSubscription] = await Promise.all([
+            this.wsChannel.subscribeEvents({
+                fromAddress: this.starknetSwapContract.contract.address,
+                keys: this.starknetSwapContract.Events.toFilter(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], []),
+                finalityStatus: starknet_1.TransactionFinalityStatus.ACCEPTED_ON_L2
+            }),
+            this.wsChannel.subscribeEvents({
+                fromAddress: this.starknetSpvVaultContract.contract.address,
+                keys: this.starknetSpvVaultContract.Events.toFilter(["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"], []),
+                finalityStatus: starknet_1.TransactionFinalityStatus.ACCEPTED_ON_L2
+            })
+        ]);
+        escrowContractSubscription.on((event) => {
+            const parsedEvents = this.starknetSwapContract.Events.toStarknetAbiEvents([event]);
+            this.processEvents(parsedEvents, event.block_number);
+        });
+        this.escrowContractSubscription = escrowContractSubscription;
+        spvVaultContractSubscription.on((event) => {
+            const parsedEvents = this.starknetSpvVaultContract.Events.toStarknetAbiEvents([event]);
+            this.processEvents(parsedEvents, event.block_number);
+        });
+        this.spvVaultContractSubscription = spvVaultContractSubscription;
+    }
+    async init() {
+        if (this.wsChannel != null) {
+            await this.setupWebsocket();
+        }
+        else {
+            await this.setupPoll();
+        }
+        this.stopped = false;
     }
     async stop() {
         this.stopped = true;
         if (this.timeout != null)
             clearTimeout(this.timeout);
+        if (this.wsStarted) {
+            await this.escrowContractSubscription.unsubscribe();
+            await this.spvVaultContractSubscription.unsubscribe();
+            this.wsStarted = false;
+        }
     }
     registerListener(cbk) {
         this.listeners.push(cbk);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "7.0.3",
+  "version": "7.0.5",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,7 +33,8 @@
     "@scure/btc-signer": "^1.6.0",
     "abi-wan-kanabi": "2.2.4",
     "buffer": "6.0.3",
-    "promise-queue-ts": "^1.0.0"
+    "promise-queue-ts": "^1.0.0",
+    "ws": "^8.18.3"
   },
   "peerDependencies": {
     "starknet": "^8.5.0"

package/src/starknet/StarknetInitializer.ts

@@ -1,4 +1,4 @@
-import {constants, Provider} from "starknet";
+import {constants, Provider, WebSocketChannel} from "starknet";
 import {StarknetFees} from "./chain/modules/StarknetFees";
 import {StarknetChainInterface, StarknetConfig, StarknetRetryPolicy} from "./chain/StarknetChainInterface";
 import {StarknetBtcRelay} from "./btcrelay/StarknetBtcRelay";
@@ -41,6 +41,7 @@ export const StarknetAssets: StarknetAssetsType = {
 
 export type StarknetOptions = {
     rpcUrl: string | Provider,
+    wsUrl?: string | WebSocketChannel,
     retryPolicy?: StarknetRetryPolicy,
     chainId?: constants.StarknetChainId,
 
@@ -69,13 +70,17 @@ export function initializeStarknet(
     const provider = typeof(options.rpcUrl)==="string" ?
         new RpcProviderWithRetries({nodeUrl: options.rpcUrl}) :
         options.rpcUrl;
+    let wsChannel: WebSocketChannel;
+    if(options.wsUrl!=null) wsChannel = typeof(options.wsUrl)==="string" ?
+        new WebSocketChannel({nodeUrl: options.wsUrl, websocket: typeof window !== "undefined" && typeof window.WebSocket !== "undefined" ? window.WebSocket : require("ws")}) :
+        options.wsUrl;
 
     const Fees = options.fees ?? new StarknetFees(provider);
 
     const chainId = options.chainId ??
         (network===BitcoinNetwork.MAINNET ? constants.StarknetChainId.SN_MAIN : constants.StarknetChainId.SN_SEPOLIA);
 
-    const chainInterface = new StarknetChainInterface(chainId, provider, options.retryPolicy, Fees, options.starknetConfig);
+    const chainInterface = new StarknetChainInterface(chainId, provider, wsChannel, options.retryPolicy, Fees, options.starknetConfig);
 
     const btcRelay = new StarknetBtcRelay(
         chainInterface, bitcoinRpc, network, options.btcRelayContract

package/src/starknet/chain/StarknetChainInterface.ts

@@ -1,4 +1,4 @@
-import {Provider, constants, stark, ec, Account, provider, wallet} from "starknet";
+import {Provider, constants, stark, ec, Account, provider, wallet, WebSocketChannel} from "starknet";
 import {getLogger, toHex} from "../../utils/Utils";
 import {StarknetTransactions, StarknetTx} from "./modules/StarknetTransactions";
 import {StarknetFees} from "./modules/StarknetFees";
@@ -32,6 +32,7 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Starkn
 
     readonly chainId = "STARKNET";
 
+    readonly wsChannel?: WebSocketChannel;
     readonly provider: Provider;
     readonly retryPolicy: StarknetRetryPolicy;
 
@@ -52,6 +53,7 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Starkn
     constructor(
         chainId: constants.StarknetChainId,
         provider: Provider,
+        wsChannel?: WebSocketChannel,
         retryPolicy?: StarknetRetryPolicy,
         feeEstimator: StarknetFees = new StarknetFees(provider),
         options?: StarknetConfig
@@ -64,6 +66,7 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Starkn
         this.config.getLogChunkSize ??= 100;
         this.config.maxGetLogKeys ??= 64;
         this.config.maxParallelCalls ??= 10;
+        this.wsChannel = wsChannel;
 
         this.Fees = feeEstimator;
         this.Tokens = new StarknetTokens(this);

package/src/starknet/contract/modules/StarknetContractEvents.ts

@@ -27,7 +27,7 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
         this.abi = abi;
     }
 
-    private toStarknetAbiEvents<T extends ExtractAbiEventNames<TAbi>>(blockEvents: StarknetEvent[]): StarknetAbiEvent<TAbi, T>[] {
+    public toStarknetAbiEvents<T extends ExtractAbiEventNames<TAbi>>(blockEvents: StarknetEvent[]): StarknetAbiEvent<TAbi, T>[] {
         const abiEvents = events.getAbiEvents(this.abi);
         const abiStructs = CallData.getAbiStruct(this.abi);
         const abiEnums = CallData.getAbiEnum(this.abi);
@@ -49,7 +49,7 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
         });
     }
 
-    private toFilter<T extends ExtractAbiEventNames<TAbi>>(
+    public toFilter<T extends ExtractAbiEventNames<TAbi>>(
         events: T[],
         keys: (string | string[])[],
     ): string[][] {

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,16 @@ 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();
+        if(this.wsChannel!=null) await this.setupWebsocket();
         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

@@ -17,7 +17,15 @@ import {
     toHex
 } from "../../utils/Utils";
 import {StarknetSwapContract} from "../swaps/StarknetSwapContract";
-import {BigNumberish, BlockTag, hash, Provider} from "starknet";
+import {
+    BigNumberish,
+    BlockTag,
+    hash,
+    Provider,
+    SubscriptionStarknetEventsEvent,
+    TransactionFinalityStatus,
+    WebSocketChannel
+} from "starknet";
 import {StarknetAbiEvent} from "../contract/modules/StarknetContractEvents";
 import {EscrowManagerAbiType} from "../swaps/EscrowManagerAbi";
 import {ExtractAbiFunctionNames} from "abi-wan-kanabi/dist/kanabi";
@@ -25,6 +33,11 @@ import {IClaimHandler} from "../swaps/handlers/claim/ClaimHandlers";
 import {StarknetSpvVaultContract} from "../spv_swap/StarknetSpvVaultContract";
 import {StarknetChainInterface} from "../chain/StarknetChainInterface";
 import {SpvVaultContractAbiType} from "../spv_swap/SpvVaultContractAbi";
+import {sha256} from "@noble/hashes/sha2";
+import {Buffer} from "buffer";
+
+const PROCESSED_EVENTS_BACKLOG = 5000;
+const LOGS_SLIDING_WINDOW = 60;
 
 export type StarknetTraceCall = {
     calldata: string[],
@@ -33,6 +46,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
@@ -40,12 +55,22 @@ export type StarknetTraceCall = {
  */
 export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData> {
 
+    private eventsProcessing: {
+        [eventFingerprint: string]: Promise<void>
+    } = {};
+    private processedEvents: Set<string> = new Set();
+
+    protected readonly Chain: StarknetChainInterface;
     protected readonly listeners: EventListener<StarknetSwapData>[] = [];
+    protected readonly wsChannel?: WebSocketChannel;
     protected readonly provider: Provider;
     protected readonly starknetSwapContract: StarknetSwapContract;
     protected readonly starknetSpvVaultContract: StarknetSpvVaultContract;
     protected readonly logger = getLogger("StarknetChainEventsBrowser: ");
 
+    protected escrowContractSubscription: SubscriptionStarknetEventsEvent;
+    protected spvVaultContractSubscription: SubscriptionStarknetEventsEvent;
+
     protected initFunctionName: ExtractAbiFunctionNames<EscrowManagerAbiType> = "initialize";
     protected initEntryPointSelector = BigInt(hash.starknetKeccak(this.initFunctionName));
 
@@ -60,12 +85,34 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
         starknetSpvVaultContract: StarknetSpvVaultContract,
         pollIntervalSeconds: number = 5
     ) {
+        this.Chain = chainInterface;
+        this.wsChannel = chainInterface.wsChannel;
         this.provider = chainInterface.provider;
         this.starknetSwapContract = starknetSwapContract;
         this.starknetSpvVaultContract = starknetSpvVaultContract;
         this.pollIntervalSeconds = pollIntervalSeconds;
     }
 
+    private getEventFingerprint(event: {keys: string[], data: string[], txHash: string}): string {
+        const eventData = Buffer.concat([
+            ...event.keys.map(value => bigNumberishToBuffer(value, 64)),
+            ...event.data.map(value => bigNumberishToBuffer(value, 64))
+        ]);
+        const fingerprint = Buffer.from(sha256(eventData));
+
+        return event.txHash+":"+fingerprint.toString("hex");
+    }
+
+    private addProcessedEvent(event: {keys: string[], data: string[], txHash: string}) {
+        this.processedEvents.add(this.getEventFingerprint(event));
+        if(this.processedEvents.size > PROCESSED_EVENTS_BACKLOG) this.processedEvents.delete(this.processedEvents.keys().next().value);
+    }
+
+    private isEventProcessed(eventOrFingerprint: {keys: string[], data: string[], txHash: string} | string): boolean {
+        const eventFingerprint: string = typeof(eventOrFingerprint)==="string" ? eventOrFingerprint : this.getEventFingerprint(eventOrFingerprint);
+        return this.processedEvents.has(eventFingerprint);
+    }
+
     findInitSwapData(call: StarknetTraceCall, escrowHash: BigNumberish, claimHandler: IClaimHandler<any, any>): StarknetSwapData {
         if(
             BigInt(call.contract_address)===BigInt(this.starknetSwapContract.contract.address) &&
@@ -249,19 +296,24 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
             "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
+        currentBlockTimestamp?: number
     ) {
         const blockTimestampsCache: {[blockNumber: string]: number} = {};
         const getBlockTimestamp: (blockNumber: number) => Promise<number> = async (blockNumber: number)=> {
             if(blockNumber===currentBlockNumber) return currentBlockTimestamp;
             const blockNumberString = blockNumber.toString();
-            blockTimestampsCache[blockNumberString] ??= (await this.provider.getBlockWithTxHashes(blockNumber)).timestamp;
+            blockTimestampsCache[blockNumberString] ??= await this.Chain.Blocks.getBlockTime(blockNumber);
             return blockTimestampsCache[blockNumberString];
         }
 
-        const parsedEvents: ChainEvent<StarknetSwapData>[] = [];
-
         for(let event of events) {
+            const eventIdentifier = this.getEventFingerprint(event);
+
+            if(this.isEventProcessed(eventIdentifier)) {
+                this.logger.debug("processEvents(): skipping already processed event: "+eventIdentifier);
+                continue;
+            }
+
             let parsedEvent: ChainEvent<StarknetSwapData>;
             switch(event.name) {
                 case "escrow_manager::events::Claim":
@@ -289,26 +341,47 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
                     parsedEvent = this.parseSpvCloseEvent(event as any);
                     break;
             }
-            if(parsedEvent==null) continue;
-            //We are not trusting pre-confs for events, so this shall never happen
-            if(event.blockNumber==null) throw new Error("Event block number cannot be null!");
-            const timestamp = await getBlockTimestamp(event.blockNumber);
-            parsedEvent.meta = {
-                blockTime: timestamp,
-                txId: event.txHash,
-                timestamp //Maybe deprecated
-            } as any;
-            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() => {
+                if(parsedEvent==null) return;
+                //We are not trusting pre-confs for events, so this shall never happen
+                if(event.blockNumber==null) throw new Error("Event block number cannot be null!");
+                const timestamp = await getBlockTimestamp(event.blockNumber);
+                parsedEvent.meta = {
+                    blockTime: timestamp,
+                    txId: event.txHash,
+                    timestamp //Maybe deprecated
+                } as any;
+                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;
+            }
         }
     }
 
-    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 +393,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 +426,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;
+        const currentBlock = await this.Chain.Blocks.getBlock(BlockTag.LATEST);
 
-        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 +461,14 @@ 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);
             });
@@ -395,14 +478,67 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
         await func();
     }
 
-    init(): Promise<void> {
-        this.setupPoll();
-        return Promise.resolve();
+    protected wsStarted: boolean = false;
+
+    protected async setupWebsocket() {
+        this.wsStarted = true;
+
+        const [
+            escrowContractSubscription,
+            spvVaultContractSubscription
+        ] = await Promise.all([
+            this.wsChannel.subscribeEvents({
+                fromAddress: this.starknetSwapContract.contract.address,
+                keys: this.starknetSwapContract.Events.toFilter(
+                    ["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"],
+                    []
+                ),
+                finalityStatus: TransactionFinalityStatus.ACCEPTED_ON_L2
+            }),
+            this.wsChannel.subscribeEvents({
+                fromAddress: this.starknetSpvVaultContract.contract.address,
+                keys: this.starknetSpvVaultContract.Events.toFilter(
+                    ["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"],
+                    []
+                ),
+                finalityStatus: TransactionFinalityStatus.ACCEPTED_ON_L2
+            })
+        ]);
+
+        escrowContractSubscription.on((event) => {
+            const parsedEvents = this.starknetSwapContract.Events.toStarknetAbiEvents<
+                "escrow_manager::events::Initialize" | "escrow_manager::events::Claim" | "escrow_manager::events::Refund"
+            >([event]);
+            this.processEvents(parsedEvents, event.block_number);
+        });
+        this.escrowContractSubscription = escrowContractSubscription;
+
+        spvVaultContractSubscription.on((event) => {
+            const parsedEvents = this.starknetSpvVaultContract.Events.toStarknetAbiEvents<
+                "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"
+            >([event]);
+            this.processEvents(parsedEvents, event.block_number);
+        });
+        this.spvVaultContractSubscription = spvVaultContractSubscription;
+    }
+
+    async init(): Promise<void> {
+        if(this.wsChannel!=null) {
+            await this.setupWebsocket();
+        } else {
+            await this.setupPoll();
+        }
+        this.stopped = false;
     }
 
     async stop(): Promise<void> {
         this.stopped = true;
         if(this.timeout!=null) clearTimeout(this.timeout);
+        if(this.wsStarted) {
+            await this.escrowContractSubscription.unsubscribe();
+            await this.spvVaultContractSubscription.unsubscribe();
+            this.wsStarted = false;
+        }
     }
 
     registerListener(cbk: EventListener<StarknetSwapData>): void {