@atomiqlabs/chain-starknet 7.0.4 → 7.0.6

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

@@ -45,6 +45,8 @@ class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEven
     }
     async init() {
         const lastEventsState = await this.getLastEventData();
+        if (this.wsChannel != null)
+            await this.setupWebsocket();
         await this.setupPoll(lastEventsState, (newState) => this.saveLastEventData(newState));
     }
 }

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";
@@ -25,17 +25,26 @@ export type StarknetEventListenerState = {
  *  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
@@ -62,7 +71,7 @@ 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 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;
@@ -78,6 +87,8 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
      * @protected
      */
     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,9 @@ 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
@@ -12,15 +15,37 @@ const LOGS_SLIDING_WINDOW = 60;
  */
 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) {
@@ -165,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":
@@ -197,21 +226,37 @@ 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(currentBlock, lastTxHash, lastBlockNumber) {
@@ -274,7 +319,7 @@ class StarknetChainEventsBrowser {
     }
     async checkEvents(lastState) {
         lastState ?? (lastState = []);
-        const currentBlock = await this.provider.getBlockWithTxHashes(starknet_1.BlockTag.LATEST);
+        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 [
@@ -288,7 +333,6 @@ class StarknetChainEventsBrowser {
      * @protected
      */
     async setupPoll(lastState, saveLatestProcessedBlockNumber) {
-        this.stopped = false;
         let func;
         func = async () => {
             await this.checkEvents(lastState).then(newState => {
@@ -304,14 +348,60 @@ class StarknetChainEventsBrowser {
         };
         await func();
     }
-    init() {
-        this.setupPoll();
-        return Promise.resolve();
+    async setupWebsocket() {
+        this.wsStarted = true;
+        this.wsChannel.on("open", () => {
+            this.logger.info("setupWebsocket(): Websocket connection opened!");
+        });
+        this.wsChannel.on("close", () => {
+            this.logger.warn("setupWebsocket(): Websocket connection closed!");
+        });
+        this.wsChannel.on("error", (err) => {
+            this.logger.error("setupWebsocket(): Websocket connection error: ", err);
+        });
+        await this.wsChannel.waitForConnection();
+        this.logger.info("setupWebsocket(): Websocket connection awaited successfully!");
+        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.4",
+  "version": "7.0.6",
   "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

@@ -59,6 +59,7 @@ export class StarknetChainEvents extends StarknetChainEventsBrowser {
 
     async init(): Promise<void> {
         const lastEventsState = await this.getLastEventData();
+        if(this.wsChannel!=null) await this.setupWebsocket();
         await this.setupPoll(
             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,7 +33,10 @@ 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 = {
@@ -44,12 +55,22 @@ export type StarknetEventListenerState = {lastBlockNumber: number, lastTxHash?:
  */
 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));
 
@@ -64,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) &&
@@ -253,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":
@@ -293,20 +341,37 @@ 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;
+            }
         }
     }
 
@@ -379,7 +444,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
     protected async checkEvents(lastState: StarknetEventListenerState[]): Promise<StarknetEventListenerState[]> {
         lastState ??= [];
 
-        const currentBlock = await this.provider.getBlockWithTxHashes(BlockTag.LATEST);
+        const currentBlock = await this.Chain.Blocks.getBlock(BlockTag.LATEST);
 
         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);
@@ -399,7 +464,6 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
         lastState?: StarknetEventListenerState[],
         saveLatestProcessedBlockNumber?: (newState: StarknetEventListenerState[]) => Promise<void>
     ) {
-        this.stopped = false;
         let func;
         func = async () => {
             await this.checkEvents(lastState).then(newState => {
@@ -414,14 +478,79 @@ 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;
+
+        this.wsChannel.on("open", () => {
+            this.logger.info("setupWebsocket(): Websocket connection opened!");
+        });
+        this.wsChannel.on("close", () => {
+            this.logger.warn("setupWebsocket(): Websocket connection closed!");
+        });
+        this.wsChannel.on("error", (err) => {
+            this.logger.error("setupWebsocket(): Websocket connection error: ", err);
+        });
+        await this.wsChannel.waitForConnection();
+        this.logger.info("setupWebsocket(): Websocket connection awaited successfully!");
+
+        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 {