@atomiqlabs/chain-starknet 4.0.0-dev.36 → 4.0.0-dev.37

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

@@ -50,6 +50,10 @@ export declare class StarknetChainInterface implements ChainInterface<StarknetTx
     deserializeTx(txData: string): Promise<StarknetTx>;
     getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
     getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+    getFinalizedBlock(): Promise<{
+        height: number;
+        blockHash: string;
+    }>;
     txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<StarknetTx[]>;
     transfer(signer: StarknetSigner, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
     wrapSigner(signer: Account): Promise<StarknetSigner>;

package/dist/starknet/chain/StarknetChainInterface.js

@@ -89,6 +89,13 @@ class StarknetChainInterface {
     getTxStatus(tx) {
         return this.Transactions.getTxStatus(tx);
     }
+    async getFinalizedBlock() {
+        const block = await this.Blocks.getBlock("l1_accepted");
+        return {
+            height: block.block_number,
+            blockHash: block.block_hash
+        };
+    }
     txsTransfer(signer, token, amount, dstAddress, feeRate) {
         return this.Tokens.txsTransfer(signer, token, amount, dstAddress, feeRate);
     }

package/dist/starknet/chain/modules/StarknetBlocks.d.ts

@@ -1,5 +1,6 @@
 import { StarknetModule } from "../StarknetModule";
-export type StarknetBlockTag = "pre_confirmed" | "latest";
+import { BlockWithTxHashes } from "starknet";
+export type StarknetBlockTag = "pre_confirmed" | "latest" | "l1_accepted";
 export declare class StarknetBlocks extends StarknetModule {
     private BLOCK_CACHE_TIME;
     private blockCache;
@@ -11,6 +12,12 @@ export declare class StarknetBlocks extends StarknetModule {
      */
     private fetchAndSaveBlockTime;
     private cleanupBlocks;
+    /**
+     * Gets the block for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    getBlock(blockTag: StarknetBlockTag | number): Promise<BlockWithTxHashes>;
     /**
      * Gets the block for a given blocktag, with caching
      *

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

@@ -16,19 +16,19 @@ class StarknetBlocks extends StarknetModule_1.StarknetModule {
      */
     fetchAndSaveBlockTime(blockTag) {
         const blockTagStr = blockTag.toString(10);
-        const blockTimePromise = this.provider.getBlockWithTxHashes(blockTag).then(result => result.timestamp);
+        const blockPromise = this.provider.getBlockWithTxHashes(blockTag);
         const timestamp = Date.now();
         this.blockCache[blockTagStr] = {
-            blockTime: blockTimePromise,
+            block: blockPromise,
             timestamp
         };
-        blockTimePromise.catch(e => {
-            if (this.blockCache[blockTagStr] != null && this.blockCache[blockTagStr].blockTime === blockTimePromise)
+        blockPromise.catch(e => {
+            if (this.blockCache[blockTagStr] != null && this.blockCache[blockTagStr].block === blockPromise)
                 delete this.blockCache[blockTagStr];
             throw e;
         });
         return {
-            blockTime: blockTimePromise,
+            block: blockPromise,
             timestamp
         };
     }
@@ -52,13 +52,22 @@ class StarknetBlocks extends StarknetModule_1.StarknetModule {
      *
      * @param blockTag
      */
-    getBlockTime(blockTag) {
+    getBlock(blockTag) {
         this.cleanupBlocks();
         let cachedBlockData = this.blockCache[blockTag.toString(10)];
         if (cachedBlockData == null || Date.now() - cachedBlockData.timestamp > this.BLOCK_CACHE_TIME) {
             cachedBlockData = this.fetchAndSaveBlockTime(blockTag);
         }
-        return cachedBlockData.blockTime;
+        return cachedBlockData.block;
+    }
+    /**
+     * Gets the block for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    async getBlockTime(blockTag) {
+        const block = await this.getBlock(blockTag);
+        return block.timestamp;
     }
 }
 exports.StarknetBlocks = StarknetBlocks;

package/dist/starknet/chain/modules/StarknetEvents.d.ts

@@ -37,8 +37,9 @@ export declare class StarknetEvents extends StarknetModule {
      * @param keys
      * @param processor called for every batch of returned signatures, should return a value if the correct signature
      *  was found, or null if the search should continue
+     * @param startHeight
      * @param abortSignal
      * @param logFetchLimit
      */
-    findInEventsForward<T>(contract: string, keys: string[][], processor: (signatures: StarknetEvent[]) => Promise<T>, abortSignal?: AbortSignal, logFetchLimit?: number): Promise<T>;
+    findInEventsForward<T>(contract: string, keys: string[][], processor: (signatures: StarknetEvent[]) => Promise<T>, startHeight?: number, abortSignal?: AbortSignal, logFetchLimit?: number): Promise<T>;
 }

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

@@ -61,16 +61,18 @@ class StarknetEvents extends StarknetModule_1.StarknetModule {
      * @param keys
      * @param processor called for every batch of returned signatures, should return a value if the correct signature
      *  was found, or null if the search should continue
+     * @param startHeight
      * @param abortSignal
      * @param logFetchLimit
      */
-    async findInEventsForward(contract, keys, processor, abortSignal, logFetchLimit) {
+    async findInEventsForward(contract, keys, processor, startHeight, abortSignal, logFetchLimit) {
         if (logFetchLimit == null || logFetchLimit > this.EVENTS_LIMIT)
             logFetchLimit = this.EVENTS_LIMIT;
         let eventsResult = null;
         while (eventsResult == null || eventsResult?.continuation_token != null) {
             eventsResult = await this.root.provider.getEvents({
                 address: contract,
+                from_block: startHeight == null ? undefined : { block_number: startHeight },
                 to_block: "latest",
                 keys,
                 chunk_size: logFetchLimit ?? this.EVENTS_LIMIT,

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

@@ -45,7 +45,8 @@ export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEv
      * @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 startHeight
      * @param abortSignal
      */
-    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: (string | string[])[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: (string | string[])[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, startHeight?: number, abortSignal?: AbortSignal): Promise<T>;
 }

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

@@ -81,9 +81,10 @@ class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
      * @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 startHeight
      * @param abortSignal
      */
-    async findInContractEventsForward(events, keys, processor, abortSignal) {
+    async findInContractEventsForward(events, keys, processor, startHeight, abortSignal) {
         return this.findInEventsForward(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
             const parsedEvents = this.toStarknetAbiEvents(events);
             for (let event of parsedEvents) {
@@ -91,7 +92,7 @@ class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
                 if (result != null)
                     return result;
             }
-        }, abortSignal);
+        }, startHeight, abortSignal);
     }
 }
 exports.StarknetContractEvents = StarknetContractEvents;

package/dist/starknet/spv_swap/StarknetSpvVaultContract.d.ts

@@ -53,10 +53,13 @@ export declare class StarknetSpvVaultContract extends StarknetContractBase<typeo
         [btcTxId: string]: string | null;
     }>;
     private parseWithdrawalEvent;
-    getWithdrawalStates(btcTxIds: string[]): Promise<{
+    getWithdrawalStates(withdrawalTxs: {
+        withdrawal: StarknetSpvWithdrawalData;
+        scStartHeight?: number;
+    }[]): Promise<{
         [btcTxId: string]: SpvWithdrawalState;
     }>;
-    getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState>;
+    getWithdrawalState(withdrawalTx: StarknetSpvWithdrawalData, scStartBlockheight?: number): Promise<SpvWithdrawalState>;
     getWithdrawalData(btcTx: BtcTx): Promise<StarknetSpvWithdrawalData>;
     fromOpReturnData(data: Buffer): {
         recipient: string;

package/dist/starknet/spv_swap/StarknetSpvVaultContract.js

@@ -217,27 +217,34 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
                 return null;
         }
     }
-    async getWithdrawalStates(btcTxIds) {
+    async getWithdrawalStates(withdrawalTxs) {
         const result = {};
-        btcTxIds.forEach(txId => {
-            result[txId] = {
+        withdrawalTxs.forEach(withdrawalTx => {
+            result[withdrawalTx.withdrawal.getTxId()] = {
                 type: base_1.SpvWithdrawalStateType.NOT_FOUND
             };
         });
-        for (let i = 0; i < btcTxIds.length; i += this.Chain.config.maxGetLogKeys) {
-            const checkBtcTxIds = btcTxIds.slice(i, i + this.Chain.config.maxGetLogKeys);
+        const events = ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"];
+        for (let i = 0; i < withdrawalTxs.length; i += this.Chain.config.maxGetLogKeys) {
+            const checkWithdrawalTxs = withdrawalTxs.slice(i, i + this.Chain.config.maxGetLogKeys);
             const lows = [];
             const highs = [];
-            checkBtcTxIds.forEach(btcTxId => {
-                const txHash = buffer_1.Buffer.from(btcTxId, "hex").reverse();
+            let startHeight = undefined;
+            checkWithdrawalTxs.forEach(withdrawalTx => {
+                const txHash = buffer_1.Buffer.from(withdrawalTx.withdrawal.getTxId(), "hex").reverse();
                 const txHashU256 = starknet_1.cairo.uint256("0x" + txHash.toString("hex"));
                 lows.push((0, Utils_1.toHex)(txHashU256.low));
                 highs.push((0, Utils_1.toHex)(txHashU256.high));
+                if (startHeight !== null) {
+                    if (withdrawalTx.scStartHeight == null) {
+                        startHeight = null;
+                    }
+                    else {
+                        startHeight = Math.min(startHeight ?? Infinity, withdrawalTx.scStartHeight);
+                    }
+                }
             });
-            await this.Events.findInContractEventsForward(["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"], [
-                lows,
-                highs
-            ], async (event) => {
+            await this.Events.findInContractEventsForward(events, [lows, highs], async (event) => {
                 const txId = (0, Utils_1.bigNumberishToBuffer)(event.params.btc_tx_hash, 32).reverse().toString("hex");
                 if (result[txId] == null) {
                     this.logger.warn(`getWithdrawalStates(): findInContractEvents-callback: loaded event for ${txId}, but transaction not found in input params!`);
@@ -246,24 +253,23 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
                 const eventResult = this.parseWithdrawalEvent(event);
                 if (eventResult != null)
                     result[txId] = eventResult;
-            });
+            }, startHeight);
         }
         return result;
     }
-    async getWithdrawalState(btcTxId) {
-        const txHash = buffer_1.Buffer.from(btcTxId, "hex").reverse();
+    async getWithdrawalState(withdrawalTx, scStartBlockheight) {
+        const txHash = buffer_1.Buffer.from(withdrawalTx.getTxId(), "hex").reverse();
         const txHashU256 = starknet_1.cairo.uint256("0x" + txHash.toString("hex"));
         let result = {
             type: base_1.SpvWithdrawalStateType.NOT_FOUND
         };
-        await this.Events.findInContractEventsForward(["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"], [
-            (0, Utils_1.toHex)(txHashU256.low),
-            (0, Utils_1.toHex)(txHashU256.high)
-        ], async (event) => {
+        const events = ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"];
+        const keys = [(0, Utils_1.toHex)(txHashU256.low), (0, Utils_1.toHex)(txHashU256.high)];
+        await this.Events.findInContractEventsForward(events, keys, async (event) => {
             const eventResult = this.parseWithdrawalEvent(event);
             if (eventResult != null)
                 result = eventResult;
-        });
+        }, scStartBlockheight);
         return result;
     }
     getWithdrawalData(btcTx) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "4.0.0-dev.36",
+  "version": "4.0.0-dev.37",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -28,7 +28,7 @@
     "url": "git+https://github.com/atomiqlabs/atomiq-chain-starknet.git"
   },
   "dependencies": {
-    "@atomiqlabs/base": "^10.0.0-dev.18",
+    "@atomiqlabs/base": "^10.0.0-dev.20",
     "@noble/hashes": "^1.7.1",
     "@scure/btc-signer": "^1.6.0",
     "abi-wan-kanabi": "2.2.4",

package/src/starknet/chain/StarknetChainInterface.ts

@@ -151,6 +151,14 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Starkn
         return this.Transactions.getTxStatus(tx);
     }
 
+    async getFinalizedBlock(): Promise<{ height: number; blockHash: string }> {
+        const block = await this.Blocks.getBlock("l1_accepted");
+        return {
+            height: block.block_number as number,
+            blockHash: block.block_hash as string
+        }
+    }
+
     txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<StarknetTx[]> {
         return this.Tokens.txsTransfer(signer, token, amount, dstAddress, feeRate);
     }

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

@@ -1,7 +1,8 @@
 import {StarknetModule} from "../StarknetModule";
+import {BlockWithTxHashes} from "starknet";
 
 // https://github.com/starkware-libs/starknet-specs/blob/c2e93098b9c2ca0423b7f4d15b201f52f22d8c36/api/starknet_api_openrpc.json#L1234
-export type StarknetBlockTag = "pre_confirmed" | "latest";
+export type StarknetBlockTag = "pre_confirmed" | "latest" | "l1_accepted";
 
 export class StarknetBlocks extends StarknetModule {
 
@@ -9,7 +10,7 @@ export class StarknetBlocks extends StarknetModule {
 
     private blockCache: {
         [key: string]: {
-            blockTime: Promise<number>,
+            block: Promise<BlockWithTxHashes>,
             timestamp: number
         }
     } = {};
@@ -21,23 +22,23 @@ export class StarknetBlocks extends StarknetModule {
      * @param blockTag
      */
     private fetchAndSaveBlockTime(blockTag: StarknetBlockTag | number): {
-        blockTime: Promise<number>,
+        block: Promise<BlockWithTxHashes>,
         timestamp: number
     } {
         const blockTagStr = blockTag.toString(10);
 
-        const blockTimePromise = this.provider.getBlockWithTxHashes(blockTag).then(result => result.timestamp);
+        const blockPromise = this.provider.getBlockWithTxHashes(blockTag);
         const timestamp = Date.now();
         this.blockCache[blockTagStr] = {
-            blockTime: blockTimePromise,
+            block: blockPromise,
             timestamp
         };
-        blockTimePromise.catch(e => {
-            if(this.blockCache[blockTagStr]!=null && this.blockCache[blockTagStr].blockTime===blockTimePromise) delete this.blockCache[blockTagStr];
+        blockPromise.catch(e => {
+            if(this.blockCache[blockTagStr]!=null && this.blockCache[blockTagStr].block===blockPromise) delete this.blockCache[blockTagStr];
             throw e;
         })
         return {
-            blockTime: blockTimePromise,
+            block: blockPromise,
             timestamp
         };
     }
@@ -62,7 +63,7 @@ export class StarknetBlocks extends StarknetModule {
      *
      * @param blockTag
      */
-    public getBlockTime(blockTag: StarknetBlockTag | number): Promise<number> {
+    public getBlock(blockTag: StarknetBlockTag | number): Promise<BlockWithTxHashes> {
         this.cleanupBlocks();
         let cachedBlockData = this.blockCache[blockTag.toString(10)];
 
@@ -70,7 +71,17 @@ export class StarknetBlocks extends StarknetModule {
             cachedBlockData = this.fetchAndSaveBlockTime(blockTag);
         }
 
-        return cachedBlockData.blockTime;
+        return cachedBlockData.block;
+    }
+
+    /**
+     * Gets the block for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    public async getBlockTime(blockTag: StarknetBlockTag | number): Promise<number> {
+        const block = await this.getBlock(blockTag);
+        return block.timestamp;
     }
 
 }

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

@@ -76,12 +76,14 @@ export class StarknetEvents extends StarknetModule {
      * @param keys
      * @param processor called for every batch of returned signatures, should return a value if the correct signature
      *  was found, or null if the search should continue
+     * @param startHeight
      * @param abortSignal
      * @param logFetchLimit
      */
     public async findInEventsForward<T>(
         contract: string, keys: string[][],
         processor: (signatures: StarknetEvent[]) => Promise<T>,
+        startHeight?: number,
         abortSignal?: AbortSignal,
         logFetchLimit?: number
     ): Promise<T> {
@@ -90,6 +92,7 @@ export class StarknetEvents extends StarknetModule {
         while(eventsResult==null || eventsResult?.continuation_token!=null) {
             eventsResult = await this.root.provider.getEvents({
                 address: contract,
+                from_block: startHeight==null ? undefined : {block_number: startHeight},
                 to_block: "latest",
                 keys,
                 chunk_size: logFetchLimit ?? this.EVENTS_LIMIT,

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

@@ -113,12 +113,14 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
      * @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 startHeight
      * @param abortSignal
      */
     public async findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(
         events: TEvent[],
         keys: (string | string[])[],
         processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>,
+        startHeight?: number,
         abortSignal?: AbortSignal
     ) {
         return this.findInEventsForward<T>(this.contract.contract.address, this.toFilter(events, keys), async (events: StarknetEvent[]) => {
@@ -127,7 +129,7 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
                 const result: T = await processor(event);
                 if(result!=null) return result;
             }
-        }, abortSignal);
+        }, startHeight, abortSignal);
     }
 
 }

package/src/starknet/spv_swap/StarknetSpvVaultContract.ts

@@ -6,7 +6,7 @@ import {
     SpvVaultTokenData,
     SpvWithdrawalState,
     SpvWithdrawalStateType,
-    SpvWithdrawalTransactionData, SwapCommitState,
+    SpvWithdrawalTransactionData,
     TransactionConfirmationOptions
 } from "@atomiqlabs/base";
 import {Buffer} from "buffer";
@@ -297,30 +297,38 @@ export class StarknetSpvVaultContract
         }
     }
 
-    async getWithdrawalStates(btcTxIds: string[]): Promise<{[btcTxId: string]: SpvWithdrawalState}> {
+    async getWithdrawalStates(withdrawalTxs: {withdrawal: StarknetSpvWithdrawalData, scStartHeight?: number}[]): Promise<{[btcTxId: string]: SpvWithdrawalState}> {
         const result: {[btcTxId: string]: SpvWithdrawalState} = {};
-        btcTxIds.forEach(txId => {
-            result[txId] = {
+        withdrawalTxs.forEach(withdrawalTx => {
+            result[withdrawalTx.withdrawal.getTxId()] = {
                 type: SpvWithdrawalStateType.NOT_FOUND
             };
         });
 
-        for(let i=0;i<btcTxIds.length;i+=this.Chain.config.maxGetLogKeys) {
-            const checkBtcTxIds = btcTxIds.slice(i, i+this.Chain.config.maxGetLogKeys);
+        const events: ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"] =
+            ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"];
+
+        for(let i=0;i<withdrawalTxs.length;i+=this.Chain.config.maxGetLogKeys) {
+            const checkWithdrawalTxs = withdrawalTxs.slice(i, i+this.Chain.config.maxGetLogKeys);
             const lows: string[] = [];
             const highs: string[] = [];
-            checkBtcTxIds.forEach(btcTxId => {
-                const txHash = Buffer.from(btcTxId, "hex").reverse();
+            let startHeight: number = undefined;
+            checkWithdrawalTxs.forEach(withdrawalTx => {
+                const txHash = Buffer.from(withdrawalTx.withdrawal.getTxId(), "hex").reverse();
                 const txHashU256 = cairo.uint256("0x"+txHash.toString("hex"));
                 lows.push(toHex(txHashU256.low));
                 highs.push(toHex(txHashU256.high));
+                if(startHeight!==null) {
+                    if(withdrawalTx.scStartHeight==null) {
+                        startHeight = null;
+                    } else {
+                        startHeight = Math.min(startHeight ?? Infinity, withdrawalTx.scStartHeight);
+                    }
+                }
             });
+
             await this.Events.findInContractEventsForward(
-                ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"],
-                [
-                    lows,
-                    highs
-                ],
+                events,[lows, highs],
                 async (event) => {
                     const txId = bigNumberishToBuffer(event.params.btc_tx_hash, 32).reverse().toString("hex");
                     if(result[txId]==null) {
@@ -329,29 +337,31 @@ export class StarknetSpvVaultContract
                     }
                     const eventResult = this.parseWithdrawalEvent(event);
                     if(eventResult!=null) result[txId] = eventResult;
-                }
+                },
+                startHeight
             );
         }
 
         return result;
     }
 
-    async getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState> {
-        const txHash = Buffer.from(btcTxId, "hex").reverse();
+    async getWithdrawalState(withdrawalTx: StarknetSpvWithdrawalData, scStartBlockheight?: number): Promise<SpvWithdrawalState> {
+        const txHash = Buffer.from(withdrawalTx.getTxId(), "hex").reverse();
         const txHashU256 = cairo.uint256("0x"+txHash.toString("hex"));
         let result: SpvWithdrawalState = {
             type: SpvWithdrawalStateType.NOT_FOUND
         };
+        const events: ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"] =
+            ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"];
+        const keys = [toHex(txHashU256.low), toHex(txHashU256.high)];
+
         await this.Events.findInContractEventsForward(
-            ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"],
-            [
-                toHex(txHashU256.low),
-                toHex(txHashU256.high)
-            ],
+            events, keys,
             async (event) => {
                 const eventResult = this.parseWithdrawalEvent(event);
                 if(eventResult!=null) result = eventResult;
-            }
+            },
+            scStartBlockheight
         );
         return result;
     }