@atomiqlabs/chain-starknet 1.0.8 → 2.0.0-beta.0

package/src/starknet/contract/StarknetContractBase.ts

@@ -1,29 +1,26 @@
-import {StarknetBase, StarknetRetryPolicy} from "../base/StarknetBase";
-import {constants, Contract, Provider, TypedContractV2} from "starknet";
-import {StarknetFees} from "../base/modules/StarknetFees";
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
+import {Contract, TypedContractV2} from "starknet";
 import {Abi} from "abi-wan-kanabi";
 import {StarknetContractEvents} from "./modules/StarknetContractEvents";
 
 /**
  * Base class providing program specific utilities
  */
-export class StarknetContractBase<T extends Abi> extends StarknetBase {
+export class StarknetContractBase<T extends Abi> {
 
     contract: TypedContractV2<T>;
 
     public readonly Events: StarknetContractEvents<T>;
+    public readonly Chain: StarknetChainInterface;
 
     constructor(
-        chainId: constants.StarknetChainId,
-        provider: Provider,
+        chainInterface: StarknetChainInterface,
         contractAddress: string,
-        contractAbi: T,
-        retryPolicy?: StarknetRetryPolicy,
-        solanaFeeEstimator: StarknetFees = new StarknetFees(provider)
+        contractAbi: T
     ) {
-        super(chainId, provider, retryPolicy, solanaFeeEstimator);
-        this.contract = new Contract(contractAbi, contractAddress, provider).typedv2(contractAbi);
-        this.Events = new StarknetContractEvents(this, contractAbi);
+        this.Chain = chainInterface;
+        this.contract = new Contract(contractAbi, contractAddress, chainInterface.provider).typedv2(contractAbi);
+        this.Events = new StarknetContractEvents(chainInterface, this, contractAbi);
     }
 
 }

package/src/starknet/contract/StarknetContractModule.ts

@@ -0,0 +1,16 @@
+import {Abi} from "abi-wan-kanabi";
+import {StarknetContractBase} from "./StarknetContractBase";
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
+import {StarknetModule} from "../chain/StarknetModule";
+
+
+export class StarknetContractModule<TAbi extends Abi> extends StarknetModule {
+
+    readonly contract: StarknetContractBase<TAbi>;
+
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>) {
+        super(chainInterface)
+        this.contract = contract;
+    }
+
+}

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

@@ -1,9 +1,10 @@
 import {Abi} from "abi-wan-kanabi";
 import {EventToPrimitiveType, ExtractAbiEventNames} from "abi-wan-kanabi/dist/kanabi";
-import {StarknetEvent, StarknetEvents} from "../../base/modules/StarknetEvents";
+import {StarknetEvent, StarknetEvents} from "../../chain/modules/StarknetEvents";
 import {CallData, events, hash} from "starknet";
 import {StarknetContractBase} from "../StarknetContractBase";
 import {toHex} from "../../../utils/Utils";
+import {StarknetChainInterface} from "../../chain/StarknetChainInterface";
 
 export type StarknetAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = {
     name: TEventName,
@@ -17,11 +18,12 @@ export type StarknetAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEven
 
 export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
 
-    readonly root: StarknetContractBase<TAbi>;
+    readonly contract: StarknetContractBase<TAbi>;
     readonly abi: TAbi;
 
-    constructor(root: StarknetContractBase<TAbi>, abi: TAbi) {
-        super(root);
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi) {
+        super(chainInterface);
+        this.contract = contract;
         this.abi = abi;
     }
 
@@ -76,12 +78,12 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
         startBlockHeight?: number,
         endBlockHeight: number = startBlockHeight
     ): Promise<StarknetAbiEvent<TAbi, T>[]> {
-        const blockEvents = await super.getBlockEvents(this.root.contract.address, this.toFilter(events, keys), startBlockHeight, endBlockHeight);
+        const blockEvents = await super.getBlockEvents(this.contract.contract.address, this.toFilter(events, keys), startBlockHeight, endBlockHeight);
         return this.toStarknetAbiEvents(blockEvents);
     }
 
     /**
-     * Runs a search forawrds in time, processing the events for a specific topic public key
+     * Runs a search backwards in time, processing the events for a specific topic public key
      *
      * @param events
      * @param keys
@@ -95,7 +97,31 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
         processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>,
         abortSignal?: AbortSignal
     ) {
-        return this.findInEvents<T>(this.root.contract.address, this.toFilter(events, keys), async (events: StarknetEvent[]) => {
+        return this.findInEvents<T>(this.contract.contract.address, this.toFilter(events, keys), async (events: StarknetEvent[]) => {
+            const parsedEvents = this.toStarknetAbiEvents<TEvent>(events);
+            for(let event of parsedEvents) {
+                const result: T = await processor(event);
+                if(result!=null) return result;
+            }
+        }, abortSignal);
+    }
+
+    /**
+     * Runs a search forwards in time, processing the events for a specific topic public key
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    public async findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(
+        events: TEvent[],
+        keys: string[],
+        processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>,
+        abortSignal?: AbortSignal
+    ) {
+        return this.findInEventsForward<T>(this.contract.contract.address, this.toFilter(events, keys), async (events: StarknetEvent[]) => {
             const parsedEvents = this.toStarknetAbiEvents<TEvent>(events);
             for(let event of parsedEvents) {
                 const result: T = await processor(event);

package/src/starknet/events/StarknetChainEvents.ts

@@ -2,6 +2,8 @@ import {StarknetChainEventsBrowser} from "./StarknetChainEventsBrowser";
 //@ts-ignore
 import * as fs from "fs/promises";
 import {StarknetSwapContract} from "../swaps/StarknetSwapContract";
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
+import {StarknetSpvVaultContract} from "../spv_swap/StarknetSpvVaultContract";
 
 const BLOCKHEIGHT_FILENAME = "/strk-blockheight.txt";
 
@@ -11,10 +13,12 @@ export class StarknetChainEvents extends StarknetChainEventsBrowser {
 
     constructor(
         directory: string,
+        chainInterface: StarknetChainInterface,
         starknetSwapContract: StarknetSwapContract,
+        starknetSpvVaultContract: StarknetSpvVaultContract,
         pollIntervalSeconds?: number
     ) {
-        super(starknetSwapContract, pollIntervalSeconds);
+        super(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds);
         this.directory = directory;
     }
 
@@ -23,22 +27,22 @@ export class StarknetChainEvents extends StarknetChainEventsBrowser {
      *
      * @private
      */
-    private async getLastEventData(): Promise<{blockNumber: number, txHash: string}> {
+    private async getLastEventData(): Promise<{blockNumber: number, txHashes: string[]}> {
         try {
-            const txt = (await fs.readFile(this.directory+BLOCKHEIGHT_FILENAME)).toString();
+            const txt: string = (await fs.readFile(this.directory+BLOCKHEIGHT_FILENAME)).toString();
             const arr = txt.split(";");
             if(arr.length<2) return {
                 blockNumber: parseInt(arr[0]),
-                txHash: null
+                txHashes: null
             };
             return {
                 blockNumber: parseInt(arr[0]),
-                txHash: arr[1]
+                txHashes: arr.slice(1)
             };
         } catch (e) {
             return {
                 blockNumber: null,
-                txHash: null
+                txHashes: null
             };
         }
     }
@@ -48,16 +52,16 @@ export class StarknetChainEvents extends StarknetChainEventsBrowser {
      *
      * @private
      */
-    private saveLastEventData(blockNumber: number, txHash: string): Promise<void> {
-        return fs.writeFile(this.directory+BLOCKHEIGHT_FILENAME, blockNumber.toString()+";"+txHash);
+    private saveLastEventData(blockNumber: number, txHashes: string[]): Promise<void> {
+        return fs.writeFile(this.directory+BLOCKHEIGHT_FILENAME, blockNumber.toString()+";"+txHashes.join(";"));
     }
 
     async init(): Promise<void> {
-        const {blockNumber, txHash} = await this.getLastEventData();
+        const {blockNumber, txHashes} = await this.getLastEventData();
         await this.setupPoll(
             blockNumber,
-            txHash,
-            (blockNumber: number, txHash: string) => this.saveLastEventData(blockNumber, txHash)
+            txHashes,
+            (blockNumber: number, txHashes: string[]) => this.saveLastEventData(blockNumber, txHashes)
         );
     }
 

package/src/starknet/events/StarknetChainEventsBrowser.ts

@@ -1,11 +1,11 @@
 import {
+    ChainEvent,
     ChainEvents,
     ChainSwapType,
     ClaimEvent,
     EventListener,
     InitializeEvent,
-    RefundEvent,
-    SwapEvent
+    RefundEvent, SpvVaultClaimEvent, SpvVaultCloseEvent, SpvVaultDepositEvent, SpvVaultFrontEvent, SpvVaultOpenEvent
 } from "@atomiqlabs/base";
 import {StarknetSwapData} from "../swaps/StarknetSwapData";
 import {
@@ -13,8 +13,7 @@ import {
     bytes31SpanToBuffer, findLastIndex,
     getLogger,
     onceAsync,
-    parseInitFunctionCalldata,
-    timeoutPromise,
+    parseInitFunctionCalldata, toBigInt,
     toHex
 } from "../../utils/Utils";
 import {StarknetSwapContract} from "../swaps/StarknetSwapContract";
@@ -23,6 +22,9 @@ import {StarknetAbiEvent} from "../contract/modules/StarknetContractEvents";
 import {EscrowManagerAbiType} from "../swaps/EscrowManagerAbi";
 import {ExtractAbiFunctionNames} from "abi-wan-kanabi/dist/kanabi";
 import {IClaimHandler} from "../swaps/handlers/claim/ClaimHandlers";
+import {StarknetSpvVaultContract} from "../spv_swap/StarknetSpvVaultContract";
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
+import {SpvVaultContractAbiType} from "../spv_swap/SpvVaultContractAbi";
 
 export type StarknetTraceCall = {
     calldata: string[],
@@ -41,6 +43,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
     protected readonly listeners: EventListener<StarknetSwapData>[] = [];
     protected readonly provider: Provider;
     protected readonly starknetSwapContract: StarknetSwapContract;
+    protected readonly starknetSpvVaultContract: StarknetSpvVaultContract;
     protected eventListeners: number[] = [];
     protected readonly logger = getLogger("StarknetChainEventsBrowser: ");
 
@@ -52,9 +55,15 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
 
     private timeout: number;
 
-    constructor(starknetSwapContract: StarknetSwapContract, pollIntervalSeconds: number = 5) {
-        this.provider = starknetSwapContract.provider;
+    constructor(
+        chainInterface: StarknetChainInterface,
+        starknetSwapContract: StarknetSwapContract,
+        starknetSpvVaultContract: StarknetSpvVaultContract,
+        pollIntervalSeconds: number = 5
+    ) {
+        this.provider = chainInterface.provider;
         this.starknetSwapContract = starknetSwapContract;
+        this.starknetSpvVaultContract = starknetSpvVaultContract;
         this.pollIntervalSeconds = pollIntervalSeconds;
     }
 
@@ -146,33 +155,108 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
         return new ClaimEvent<StarknetSwapData>(escrowHash, witnessResult);
     }
 
+    protected parseSpvOpenEvent(
+        event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Opened">
+    ): SpvVaultOpenEvent {
+        const owner = toHex(event.params.owner);
+        const vaultId = toBigInt(event.params.vault_id);
+        const btcTxId = bigNumberishToBuffer(event.params.btc_tx_hash, 32).reverse().toString("hex");
+        const vout = Number(toBigInt(event.params.vout));
+
+        this.logger.debug("SpvOpenEvent owner: "+owner+" vaultId: "+vaultId+" utxo: "+btcTxId+":"+vout);
+        return new SpvVaultOpenEvent(owner, vaultId, btcTxId, vout);
+    }
+
+    protected parseSpvDepositEvent(
+        event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Deposited">
+    ): SpvVaultDepositEvent {
+        const owner = toHex(event.params.owner);
+        const vaultId = toBigInt(event.params.vault_id);
+        const amounts = [toBigInt(event.params.amounts["0"] as BigNumberish), toBigInt(event.params.amounts["1"] as BigNumberish)];
+        const depositCount = Number(toBigInt(event.params.deposit_count));
+
+        this.logger.debug("SpvDepositEvent owner: "+owner+" vaultId: "+vaultId+" depositCount: "+depositCount+" amounts: ", amounts);
+        return new SpvVaultDepositEvent(owner, vaultId, amounts, depositCount);
+    }
+
+    protected parseSpvFrontEvent(
+        event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Fronted">
+    ): SpvVaultFrontEvent {
+        const owner = toHex(event.params.owner);
+        const vaultId = toBigInt(event.params.vault_id);
+        const btcTxId = bigNumberishToBuffer(event.params.btc_tx_hash, 32).reverse().toString("hex");
+        const recipient = toHex(event.params.recipient);
+        const executionHash = toHex(event.params.execution_hash);
+        const amounts = [toBigInt(event.params.amounts["0"] as BigNumberish), toBigInt(event.params.amounts["1"] as BigNumberish)];
+        const frontingAddress = toHex(event.params.caller);
+
+        this.logger.debug("SpvFrontEvent owner: "+owner+" vaultId: "+vaultId+" btcTxId: "+btcTxId+
+            " recipient: "+recipient+" frontedBy: "+frontingAddress+" amounts: ", amounts);
+        return new SpvVaultFrontEvent(owner, vaultId, btcTxId, recipient, executionHash, amounts, frontingAddress);
+    }
+
+    protected parseSpvClaimEvent(
+        event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Claimed">
+    ): SpvVaultClaimEvent {
+        const owner = toHex(event.params.owner);
+        const vaultId = toBigInt(event.params.vault_id);
+        const btcTxId = bigNumberishToBuffer(event.params.btc_tx_hash, 32).reverse().toString("hex");
+        const recipient = toHex(event.params.recipient);
+        const executionHash = toHex(event.params.execution_hash);
+        const amounts = [toBigInt(event.params.amounts["0"] as BigNumberish), toBigInt(event.params.amounts["1"] as BigNumberish)];
+        const caller = toHex(event.params.caller);
+        const frontingAddress = toHex(event.params.fronting_address);
+        const withdrawCount = Number(toBigInt(event.params.withdraw_count));
+
+        this.logger.debug("SpvClaimEvent owner: "+owner+" vaultId: "+vaultId+" btcTxId: "+btcTxId+" withdrawCount: "+withdrawCount+
+            " recipient: "+recipient+" frontedBy: "+frontingAddress+" claimedBy: "+caller+" amounts: ", amounts);
+        return new SpvVaultClaimEvent(owner, vaultId, btcTxId, recipient, executionHash, amounts, caller, frontingAddress, withdrawCount);
+    }
+
+    protected parseSpvCloseEvent(
+        event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Closed">
+    ): SpvVaultCloseEvent {
+        const owner = toHex(event.params.owner);
+        const vaultId = toBigInt(event.params.vault_id);
+        const btcTxId = bigNumberishToBuffer(event.params.btc_tx_hash, 32).reverse().toString("hex");
+        const error = bigNumberishToBuffer(event.params.error).toString();
+
+        return new SpvVaultCloseEvent(owner, vaultId, btcTxId, error);
+    }
+
     /**
      * Processes event as received from the chain, parses it & calls event listeners
      *
      * @param events
      * @param currentBlockNumber
      * @param currentBlockTimestamp
+     * @param pendingEventTime
      * @protected
      */
     protected async processEvents(
-        events : StarknetAbiEvent<
+        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
+        currentBlockTimestamp: number,
+        pendingEventTime: 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;
             return blockTimestampsCache[blockNumberString];
         }
 
-        const parsedEvents: SwapEvent<StarknetSwapData>[] = [];
+        const parsedEvents: ChainEvent<StarknetSwapData>[] = [];
 
         for(let event of events) {
-            let parsedEvent: SwapEvent<StarknetSwapData>;
+            let parsedEvent: ChainEvent<StarknetSwapData>;
             switch(event.name) {
                 case "escrow_manager::events::Claim":
                     parsedEvent = this.parseClaimEvent(event as any);
@@ -183,8 +267,23 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
                 case "escrow_manager::events::Initialize":
                     parsedEvent = this.parseInitializeEvent(event as any);
                     break;
+                case "spv_swap_vault::events::Opened":
+                    parsedEvent = this.parseSpvOpenEvent(event as any);
+                    break;
+                case "spv_swap_vault::events::Deposited":
+                    parsedEvent = this.parseSpvDepositEvent(event as any);
+                    break;
+                case "spv_swap_vault::events::Fronted":
+                    parsedEvent = this.parseSpvFrontEvent(event as any);
+                    break;
+                case "spv_swap_vault::events::Claimed":
+                    parsedEvent = this.parseSpvClaimEvent(event as any);
+                    break;
+                case "spv_swap_vault::events::Closed":
+                    parsedEvent = this.parseSpvCloseEvent(event as any);
+                    break;
             }
-            const timestamp = (event.blockNumber==null || event.blockNumber===currentBlockNumber) ? currentBlockTimestamp : await getBlockTimestamp(event.blockNumber);
+            const timestamp = event.blockNumber==null ? pendingEventTime : await getBlockTimestamp(event.blockNumber);
             parsedEvent.meta = {
                 blockTime: timestamp,
                 txId: event.txHash,
@@ -198,41 +297,69 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
         }
     }
 
-    protected async checkEvents(lastBlockNumber: number, lastTxHash: string): Promise<{txHash: string, blockNumber: number}> {
-        //Get pending events
-        let pendingEvents = await this.starknetSwapContract.Events.getContractBlockEvents(
+    protected async checkEventsEcrowManager(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {timestamp: number, block_number: number}): Promise<string> {
+        const currentBlockNumber: number = (currentBlock as any).block_number;
+        lastBlockNumber ??= currentBlockNumber;
+        const logStartHeight = currentBlockNumber>lastBlockNumber ? lastBlockNumber+1 : lastBlockNumber;
+        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"],
-            []
+            [],
+            logStartHeight,
+            null
+        );
+        if(lastTxHash!=null) {
+            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);
+            }
+        }
+        if(events.length>0) {
+            await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp, Math.floor(Date.now()/1000));
+            lastTxHash = events[events.length-1].txHash;
+        }
+        return lastTxHash;
+    }
+
+    protected async checkEventsSpvVaults(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {timestamp: number, block_number: number}): Promise<string> {
+        const currentBlockNumber: number = (currentBlock as any).block_number;
+        lastBlockNumber ??= currentBlockNumber;
+        const logStartHeight = currentBlockNumber>lastBlockNumber ? lastBlockNumber+1 : lastBlockNumber;
+        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"],
+            [],
+            logStartHeight,
+            null
         );
         if(lastTxHash!=null) {
-            const latestProcessedEventIndex = findLastIndex(pendingEvents, val => val.txHash===lastTxHash);
-            if(latestProcessedEventIndex!==-1) pendingEvents.splice(0, latestProcessedEventIndex+1);
+            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);
+            }
         }
-        if(pendingEvents.length>0) {
-            await this.processEvents(pendingEvents, null, Math.floor(Date.now()/1000));
-            lastTxHash = pendingEvents[pendingEvents.length-1].txHash;
+        if(events.length>0) {
+            await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp, Math.floor(Date.now()/1000));
+            lastTxHash = events[events.length-1].txHash;
         }
+        return lastTxHash;
+    }
+
+    protected async checkEvents(lastBlockNumber: number, lastTxHashes: string[]): Promise<{txHashes: string[], blockNumber: number}> {
+        lastTxHashes ??= [];
 
         const currentBlock = await this.provider.getBlockWithTxHashes("latest");
         const currentBlockNumber: number = (currentBlock as any).block_number;
+
         if(lastBlockNumber!=null && currentBlockNumber>lastBlockNumber) {
-            const events = await this.starknetSwapContract.Events.getContractBlockEvents(
-                ["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"],
-                [],
-                lastBlockNumber+1,
-                currentBlockNumber
-            );
-            if(lastTxHash!=null) {
-                const latestProcessedEventIndex = findLastIndex(events, val => val.txHash === lastTxHash);
-                if (latestProcessedEventIndex !== -1) events.splice(0, latestProcessedEventIndex + 1);
-            }
-            if(events.length>0) {
-                await this.processEvents(events, currentBlockNumber, currentBlock.timestamp);
-                lastTxHash = events[events.length - 1].txHash;
-            }
+            lastTxHashes[0] = await this.checkEventsEcrowManager(lastTxHashes[0], lastBlockNumber, currentBlock as any);
+            lastTxHashes[1] = await this.checkEventsSpvVaults(lastTxHashes[1], lastBlockNumber, currentBlock as any);
         }
+
         return {
-            txHash: lastTxHash,
+            txHashes: lastTxHashes,
             blockNumber: currentBlockNumber
         };
     }
@@ -244,16 +371,16 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
      */
     protected async setupPoll(
         lastBlockNumber?: number,
-        lastTxHash?: string,
-        saveLatestProcessedBlockNumber?: (blockNumber: number, lastTxHash: string) => Promise<void>
+        lastTxHashes?: string[],
+        saveLatestProcessedBlockNumber?: (blockNumber: number, lastTxHashes: string[]) => Promise<void>
     ) {
         this.stopped = false;
         let func;
         func = async () => {
-            await this.checkEvents(lastBlockNumber, lastTxHash).then(({blockNumber, txHash}) => {
+            await this.checkEvents(lastBlockNumber, lastTxHashes).then(({blockNumber, txHashes}) => {
                 lastBlockNumber = blockNumber;
-                lastTxHash = txHash;
-                if(saveLatestProcessedBlockNumber!=null) return saveLatestProcessedBlockNumber(blockNumber, lastTxHash);
+                lastTxHashes = txHashes;
+                if(saveLatestProcessedBlockNumber!=null) return saveLatestProcessedBlockNumber(blockNumber, lastTxHashes);
             }).catch(e => {
                 this.logger.error("setupPoll(): Failed to fetch starknet log: ", e);
             });

package/src/starknet/provider/RpcProviderWithRetries.ts

@@ -0,0 +1,43 @@
+import {
+    RpcChannel,
+    RpcProvider,
+    RpcProviderOptions
+} from "starknet";
+import {tryWithRetries} from "../../utils/Utils";
+
+export class RpcChannelWithRetries extends RpcChannel {
+
+    readonly retryPolicy?: {
+        maxRetries?: number, delay?: number, exponential?: boolean
+    };
+
+    constructor(options?: RpcProviderOptions, retryPolicy?: {
+        maxRetries?: number, delay?: number, exponential?: boolean
+    }) {
+        super(options);
+        this.retryPolicy = retryPolicy;
+    }
+
+    protected fetchEndpoint(method: any, params?: any): Promise<any> {
+        return tryWithRetries(() => super.fetchEndpoint(method, params), this.retryPolicy, e => {
+            if(!e.message.startsWith("RPC: ")) return false;
+            const arr = e.message.split("\n");
+            const errorCode = parseInt(arr[arr.length-1]);
+            if(isNaN(errorCode)) return false;
+            if(errorCode < 0) return false; //Not defined error, e.g. Rate limit (-32097)
+            return true;
+        });
+    }
+
+}
+
+export class RpcProviderWithRetries extends RpcProvider {
+
+    constructor(options?: RpcProviderOptions, retryPolicy?: {
+        maxRetries?: number, delay?: number, exponential?: boolean
+    }) {
+        super(options);
+        this.channel = new RpcChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
+    }
+
+}