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

package/dist/starknet/{base → chain}/modules/StarknetTokens.js

@@ -6,6 +6,7 @@ const StarknetAction_1 = require("../StarknetAction");
 const ERC20Abi_1 = require("./ERC20Abi");
 const starknet_1 = require("starknet");
 const Utils_1 = require("../../../utils/Utils");
+const StarknetAddresses_1 = require("./StarknetAddresses");
 class StarknetTokens extends StarknetModule_1.StarknetModule {
     getContract(address) {
         return new starknet_1.Contract(ERC20Abi_1.ERC20Abi, address, this.root.provider).typedv2(ERC20Abi_1.ERC20Abi);
@@ -46,7 +47,7 @@ class StarknetTokens extends StarknetModule_1.StarknetModule {
      * @param token
      */
     isValidToken(token) {
-        return this.root.Addresses.isValidAddress(token);
+        return StarknetAddresses_1.StarknetAddresses.isValidAddress(token);
     }
     /**
      * Returns the token balance of the address

package/dist/starknet/{base → chain}/modules/StarknetTransactions.d.ts

@@ -16,6 +16,7 @@ export type StarknetTx = ({
     txId?: string;
 };
 export declare class StarknetTransactions extends StarknetModule {
+    private readonly latestConfirmedNonces;
     private cbkBeforeTxSigned;
     /**
      * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
@@ -40,7 +41,6 @@ export declare class StarknetTransactions extends StarknetModule {
      * @param tx Starknet tx to send
      * @param onBeforePublish a callback called before every transaction is published
      * @param signer
-     * @param retryOnSubmissionFailure
      * @private
      */
     private sendSignedTransaction;
@@ -76,6 +76,12 @@ export declare class StarknetTransactions extends StarknetModule {
      * @param tx
      */
     getTxStatus(tx: string): Promise<"pending" | "success" | "not_found" | "reverted">;
+    /**
+     * Gets the status of the starknet transaction with a specific txId
+     *
+     * @param txId
+     */
+    _getTxIdStatus(txId: string): Promise<"pending" | "success" | "not_found" | "reverted" | "rejected">;
     /**
      * Gets the status of the starknet transaction with a specific txId
      *

package/dist/starknet/{base → chain}/modules/StarknetTransactions.js

@@ -4,6 +4,10 @@ exports.StarknetTransactions = void 0;
 const StarknetModule_1 = require("../StarknetModule");
 const Utils_1 = require("../../../utils/Utils");
 class StarknetTransactions extends StarknetModule_1.StarknetModule {
+    constructor() {
+        super(...arguments);
+        this.latestConfirmedNonces = {};
+    }
     /**
      * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
      *  the transaction at regular interval
@@ -16,14 +20,21 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
         let state = "pending";
         while (state === "pending" || state === "not_found") {
             await (0, Utils_1.timeoutPromise)(3000, abortSignal);
-            state = await this.getTxIdStatus(tx.txId);
+            state = await this._getTxIdStatus(tx.txId);
             if (state === "not_found" && tx.signed != null)
-                await this.sendSignedTransaction(tx, undefined, undefined, false).catch(e => {
+                await this.sendSignedTransaction(tx).catch(e => {
                     if (e.baseError?.code === 59)
                         return; //Transaction already in the mempool
                     console.error("Error on transaction re-send: ", e);
                 });
         }
+        if (state !== "rejected") {
+            const nextAccountNonce = (0, Utils_1.toBigInt)(tx.details.nonce) + 1n;
+            const currentNonce = this.latestConfirmedNonces[tx.details.walletAddress];
+            if (currentNonce == null || nextAccountNonce > currentNonce) {
+                this.latestConfirmedNonces[tx.details.walletAddress] = nextAccountNonce;
+            }
+        }
         if (state === "reverted")
             throw new Error("Transaction reverted!");
     }
@@ -36,6 +47,11 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
      */
     async prepareTransactions(signer, txs) {
         let nonce = await signer.getNonce();
+        const latestConfirmedNonce = this.latestConfirmedNonces[signer.getAddress()];
+        if (latestConfirmedNonce != null && latestConfirmedNonce > nonce) {
+            console.debug("StarknetTransactions: prepareTransactions(): Using nonce from local cache!");
+            nonce = latestConfirmedNonce;
+        }
         if (nonce === BigInt(0) && signer.isWalletAccount()) {
             //Just increment the nonce by one and hope the wallet is smart enough to deploy account first
             nonce = BigInt(1);
@@ -64,10 +80,9 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
      * @param tx Starknet tx to send
      * @param onBeforePublish a callback called before every transaction is published
      * @param signer
-     * @param retryOnSubmissionFailure
      * @private
      */
-    async sendSignedTransaction(tx, onBeforePublish, signer, retryOnSubmissionFailure = true) {
+    async sendSignedTransaction(tx, onBeforePublish, signer) {
         if (onBeforePublish != null)
             await onBeforePublish(tx.txId, await this.serializeTx(tx));
         this.logger.debug("sendSignedTransaction(): sending transaction: ", tx);
@@ -86,16 +101,17 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
             tx.txId = txHash;
             return txHash;
         }
-        const txResult = await (0, Utils_1.tryWithRetries)(() => {
-            switch (tx.type) {
-                case "INVOKE":
-                    return this.provider.channel.invoke(tx.signed, tx.details).then(res => res.transaction_hash);
-                case "DEPLOY_ACCOUNT":
-                    return this.provider.channel.deployAccount(tx.signed, tx.details).then((res) => res.transaction_hash);
-                default:
-                    throw new Error("Unsupported tx type!");
-            }
-        }, retryOnSubmissionFailure ? this.retryPolicy : { maxRetries: 1 });
+        let txResult;
+        switch (tx.type) {
+            case "INVOKE":
+                txResult = await this.provider.channel.invoke(tx.signed, tx.details).then(res => res.transaction_hash);
+                break;
+            case "DEPLOY_ACCOUNT":
+                txResult = await this.provider.channel.deployAccount(tx.signed, tx.details).then((res) => res.transaction_hash);
+                break;
+            default:
+                throw new Error("Unsupported tx type!");
+        }
         if (tx.txId !== txResult)
             this.logger.warn("sendSignedTransaction(): sent tx hash not matching the precomputed hash!");
         this.logger.info("sendSignedTransaction(): tx sent, expected txHash: " + tx.txId + ", txHash: " + txResult);
@@ -200,7 +216,7 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
      *
      * @param txId
      */
-    async getTxIdStatus(txId) {
+    async _getTxIdStatus(txId) {
         const status = await this.provider.getTransactionStatus(txId).catch(e => {
             if (e.message != null && e.message.includes("29: Transaction hash not found"))
                 return null;
@@ -210,11 +226,24 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
             return "not_found";
         if (status.finality_status === "RECEIVED")
             return "pending";
-        if (status.finality_status !== "REJECTED" && status.execution_status === "SUCCEEDED") {
+        if (status.finality_status === "REJECTED")
+            return "rejected";
+        if (status.execution_status === "SUCCEEDED") {
             return "success";
         }
         return "reverted";
     }
+    /**
+     * Gets the status of the starknet transaction with a specific txId
+     *
+     * @param txId
+     */
+    async getTxIdStatus(txId) {
+        const status = await this._getTxIdStatus(txId);
+        if (status === "rejected")
+            return "reverted";
+        return status;
+    }
     onBeforeTxSigned(callback) {
         this.cbkBeforeTxSigned = callback;
     }

package/dist/starknet/contract/StarknetContractBase.d.ts

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

package/dist/starknet/contract/StarknetContractBase.js

@@ -1,18 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetContractBase = void 0;
-const StarknetBase_1 = require("../base/StarknetBase");
 const starknet_1 = require("starknet");
-const StarknetFees_1 = require("../base/modules/StarknetFees");
 const StarknetContractEvents_1 = require("./modules/StarknetContractEvents");
 /**
  * Base class providing program specific utilities
  */
-class StarknetContractBase extends StarknetBase_1.StarknetBase {
-    constructor(chainId, provider, contractAddress, contractAbi, retryPolicy, solanaFeeEstimator = new StarknetFees_1.StarknetFees(provider)) {
-        super(chainId, provider, retryPolicy, solanaFeeEstimator);
-        this.contract = new starknet_1.Contract(contractAbi, contractAddress, provider).typedv2(contractAbi);
-        this.Events = new StarknetContractEvents_1.StarknetContractEvents(this, contractAbi);
+class StarknetContractBase {
+    constructor(chainInterface, contractAddress, contractAbi) {
+        this.Chain = chainInterface;
+        this.contract = new starknet_1.Contract(contractAbi, contractAddress, chainInterface.provider).typedv2(contractAbi);
+        this.Events = new StarknetContractEvents_1.StarknetContractEvents(chainInterface, this, contractAbi);
     }
 }
 exports.StarknetContractBase = StarknetContractBase;

package/dist/starknet/contract/StarknetContractModule.d.ts

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

package/dist/starknet/contract/StarknetContractModule.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetContractModule = void 0;
+const StarknetModule_1 = require("../chain/StarknetModule");
+class StarknetContractModule extends StarknetModule_1.StarknetModule {
+    constructor(chainInterface, contract) {
+        super(chainInterface);
+        this.contract = contract;
+    }
+}
+exports.StarknetContractModule = StarknetContractModule;

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

@@ -1,7 +1,8 @@
 import { Abi } from "abi-wan-kanabi";
 import { EventToPrimitiveType, ExtractAbiEventNames } from "abi-wan-kanabi/dist/kanabi";
-import { StarknetEvents } from "../../base/modules/StarknetEvents";
+import { StarknetEvents } from "../../chain/modules/StarknetEvents";
 import { StarknetContractBase } from "../StarknetContractBase";
+import { StarknetChainInterface } from "../../chain/StarknetChainInterface";
 export type StarknetAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = {
     name: TEventName;
     params: EventToPrimitiveType<TAbi, TEventName>;
@@ -12,9 +13,9 @@ export type StarknetAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEven
     data: string[];
 };
 export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
-    readonly root: StarknetContractBase<TAbi>;
+    readonly contract: StarknetContractBase<TAbi>;
     readonly abi: TAbi;
-    constructor(root: StarknetContractBase<TAbi>, abi: TAbi);
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi);
     private toStarknetAbiEvents;
     private toFilter;
     /**
@@ -28,7 +29,7 @@ export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEv
      */
     getContractBlockEvents<T extends ExtractAbiEventNames<TAbi>>(events: T[], keys: string[], startBlockHeight?: number, endBlockHeight?: number): Promise<StarknetAbiEvent<TAbi, T>[]>;
     /**
-     * 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
@@ -37,4 +38,14 @@ export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEv
      * @param abortSignal
      */
     findInContractEvents<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+    /**
+     * 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
+     */
+    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
 }

package/dist/starknet/contract/modules/StarknetContractEvents.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetContractEvents = void 0;
-const StarknetEvents_1 = require("../../base/modules/StarknetEvents");
+const StarknetEvents_1 = require("../../chain/modules/StarknetEvents");
 const starknet_1 = require("starknet");
 const Utils_1 = require("../../../utils/Utils");
 class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
-    constructor(root, abi) {
-        super(root);
+    constructor(chainInterface, contract, abi) {
+        super(chainInterface);
+        this.contract = contract;
         this.abi = abi;
     }
     toStarknetAbiEvents(blockEvents) {
@@ -51,11 +52,11 @@ class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
      * @param endBlockHeight
      */
     async getContractBlockEvents(events, keys, startBlockHeight, endBlockHeight = startBlockHeight) {
-        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
@@ -64,7 +65,26 @@ class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
      * @param abortSignal
      */
     async findInContractEvents(events, keys, processor, abortSignal) {
-        return this.findInEvents(this.root.contract.address, this.toFilter(events, keys), async (events) => {
+        return this.findInEvents(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
+            const parsedEvents = this.toStarknetAbiEvents(events);
+            for (let event of parsedEvents) {
+                const result = 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
+     */
+    async findInContractEventsForward(events, keys, processor, abortSignal) {
+        return this.findInEventsForward(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
             const parsedEvents = this.toStarknetAbiEvents(events);
             for (let event of parsedEvents) {
                 const result = await processor(event);

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

@@ -1,8 +1,10 @@
 import { StarknetChainEventsBrowser } from "./StarknetChainEventsBrowser";
 import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
+import { StarknetChainInterface } from "../chain/StarknetChainInterface";
+import { StarknetSpvVaultContract } from "../spv_swap/StarknetSpvVaultContract";
 export declare class StarknetChainEvents extends StarknetChainEventsBrowser {
     private readonly directory;
-    constructor(directory: string, starknetSwapContract: StarknetSwapContract, pollIntervalSeconds?: number);
+    constructor(directory: string, chainInterface: StarknetChainInterface, starknetSwapContract: StarknetSwapContract, starknetSpvVaultContract: StarknetSpvVaultContract, pollIntervalSeconds?: number);
     /**
      * Retrieves last signature & slot from filesystem
      *

package/dist/starknet/events/StarknetChainEvents.js

@@ -6,8 +6,8 @@ const StarknetChainEventsBrowser_1 = require("./StarknetChainEventsBrowser");
 const fs = require("fs/promises");
 const BLOCKHEIGHT_FILENAME = "/strk-blockheight.txt";
 class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEventsBrowser {
-    constructor(directory, starknetSwapContract, pollIntervalSeconds) {
-        super(starknetSwapContract, pollIntervalSeconds);
+    constructor(directory, chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds) {
+        super(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds);
         this.directory = directory;
     }
     /**
@@ -22,17 +22,17 @@ class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEven
             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
             };
         }
     }
@@ -41,12 +41,12 @@ class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEven
      *
      * @private
      */
-    saveLastEventData(blockNumber, txHash) {
-        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, blockNumber.toString() + ";" + txHash);
+    saveLastEventData(blockNumber, txHashes) {
+        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, blockNumber.toString() + ";" + txHashes.join(";"));
     }
     async init() {
-        const { blockNumber, txHash } = await this.getLastEventData();
-        await this.setupPoll(blockNumber, txHash, (blockNumber, txHash) => this.saveLastEventData(blockNumber, txHash));
+        const { blockNumber, txHashes } = await this.getLastEventData();
+        await this.setupPoll(blockNumber, txHashes, (blockNumber, txHashes) => this.saveLastEventData(blockNumber, txHashes));
     }
 }
 exports.StarknetChainEvents = StarknetChainEvents;

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

@@ -1,4 +1,4 @@
-import { ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent } from "@atomiqlabs/base";
+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";
@@ -6,6 +6,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[];
     contract_address: string;
@@ -21,6 +24,7 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
     protected readonly listeners: EventListener<StarknetSwapData>[];
     protected readonly provider: Provider;
     protected readonly starknetSwapContract: StarknetSwapContract;
+    protected readonly starknetSpvVaultContract: StarknetSpvVaultContract;
     protected eventListeners: number[];
     protected readonly logger: {
         debug: (msg: any, ...args: any[]) => void;
@@ -33,7 +37,7 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
     protected stopped: boolean;
     protected pollIntervalSeconds: number;
     private timeout;
-    constructor(starknetSwapContract: StarknetSwapContract, pollIntervalSeconds?: number);
+    constructor(chainInterface: StarknetChainInterface, starknetSwapContract: StarknetSwapContract, starknetSpvVaultContract: StarknetSpvVaultContract, pollIntervalSeconds?: number);
     findInitSwapData(call: StarknetTraceCall, escrowHash: BigNumberish, claimHandler: IClaimHandler<any, any>): StarknetSwapData;
     /**
      * Returns async getter for fetching on-demand initialize event swap data
@@ -47,6 +51,11 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
     protected parseInitializeEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize">): InitializeEvent<StarknetSwapData>;
     protected parseRefundEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Refund">): RefundEvent<StarknetSwapData>;
     protected parseClaimEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Claim">): ClaimEvent<StarknetSwapData>;
+    protected parseSpvOpenEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Opened">): SpvVaultOpenEvent;
+    protected parseSpvDepositEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Deposited">): SpvVaultDepositEvent;
+    protected parseSpvFrontEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Fronted">): SpvVaultFrontEvent;
+    protected parseSpvClaimEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Claimed">): SpvVaultClaimEvent;
+    protected parseSpvCloseEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Closed">): SpvVaultCloseEvent;
     /**
      * Processes event as received from the chain, parses it & calls event listeners
      *
@@ -56,9 +65,17 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
      * @param pendingEventTime
      * @protected
      */
-    protected processEvents(events: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize" | "escrow_manager::events::Refund" | "escrow_manager::events::Claim">[], currentBlockNumber: number, currentBlockTimestamp: number, pendingEventTime: number): Promise<void>;
-    protected checkEvents(lastBlockNumber: number, lastTxHash: string): Promise<{
-        txHash: string;
+    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, pendingEventTime: number): Promise<void>;
+    protected checkEventsEcrowManager(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {
+        timestamp: number;
+        block_number: number;
+    }): Promise<string>;
+    protected checkEventsSpvVaults(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {
+        timestamp: number;
+        block_number: number;
+    }): Promise<string>;
+    protected checkEvents(lastBlockNumber: number, lastTxHashes: string[]): Promise<{
+        txHashes: string[];
         blockNumber: number;
     }>;
     /**
@@ -66,7 +83,7 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
      *
      * @protected
      */
-    protected setupPoll(lastBlockNumber?: number, lastTxHash?: string, saveLatestProcessedBlockNumber?: (blockNumber: number, lastTxHash: string) => Promise<void>): Promise<void>;
+    protected setupPoll(lastBlockNumber?: number, lastTxHashes?: string[], saveLatestProcessedBlockNumber?: (blockNumber: number, lastTxHashes: string[]) => Promise<void>): Promise<void>;
     init(): Promise<void>;
     stop(): Promise<void>;
     registerListener(cbk: EventListener<StarknetSwapData>): void;