@atomiqlabs/chain-starknet 4.0.0-dev.35 → 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/chain/modules/StarknetTransactions.d.ts

@@ -65,7 +65,7 @@ export declare class StarknetTransactions extends StarknetModule {
      *  of a batch of starknet transactions
      *
      * @param signer
-     * @param txs transactions to send
+     * @param _txs transactions to send
      * @param waitForConfirmation whether to wait for transaction confirmations (this also makes sure the transactions
      *  are re-sent at regular intervals)
      * @param abortSignal abort signal to abort waiting for transaction confirmations
@@ -73,7 +73,7 @@ export declare class StarknetTransactions extends StarknetModule {
      *  are executed in order)
      * @param onBeforePublish a callback called before every transaction is published
      */
-    sendAndConfirm(signer: StarknetSigner, txs: StarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    sendAndConfirm(signer: StarknetSigner, _txs: StarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
     /**
      * Serializes the starknet transaction, saves the transaction, signers & last valid blockheight
      *

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

@@ -144,8 +144,11 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
         //Add deploy account tx
         if (nonce === 0n) {
             const deployPayload = await signer.getDeployPayload();
-            if (deployPayload != null)
-                txs.unshift(await this.root.Accounts.getAccountDeployTransaction(deployPayload));
+            if (deployPayload != null) {
+                const tx = await this.root.Accounts.getAccountDeployTransaction(deployPayload);
+                tx.addedInPrepare = true;
+                txs.unshift(tx);
+            }
         }
         if (!signer.isManagingNoncesInternally) {
             if (nonce === 0n) {
@@ -160,7 +163,7 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
                     nonce = BigInt(await this.root.provider.getNonceForAddress(signer.getAddress())); //Fetch the nonce
                 if (tx.details.nonce == null)
                     tx.details.nonce = nonce;
-                this.logger.debug("sendAndConfirm(): transaction prepared (" + (i + 1) + "/" + txs.length + "), nonce: " + tx.details.nonce);
+                this.logger.debug("prepareTransactions(): transaction prepared (" + (i + 1) + "/" + txs.length + "), nonce: " + tx.details.nonce);
                 nonce += BigInt(1);
             }
         }
@@ -192,7 +195,7 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
      *  of a batch of starknet transactions
      *
      * @param signer
-     * @param txs transactions to send
+     * @param _txs transactions to send
      * @param waitForConfirmation whether to wait for transaction confirmations (this also makes sure the transactions
      *  are re-sent at regular intervals)
      * @param abortSignal abort signal to abort waiting for transaction confirmations
@@ -200,7 +203,8 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
      *  are executed in order)
      * @param onBeforePublish a callback called before every transaction is published
      */
-    async sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
+    async sendAndConfirm(signer, _txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
+        const txs = _txs;
         await this.prepareTransactions(signer, txs);
         const signedTxs = [];
         //Don't separate the signing process from the sending when using browser-based wallet
@@ -208,6 +212,7 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
             for (let i = 0; i < txs.length; i++) {
                 const tx = txs[i];
                 const signedTx = await signer.signTransaction(tx);
+                signedTx.addedInPrepare = tx.addedInPrepare;
                 signedTxs.push(signedTx);
                 this.logger.debug("sendAndConfirm(): transaction signed (" + (i + 1) + "/" + txs.length + "): " + signedTx.txId);
                 const nextAccountNonce = BigInt(signedTx.details.nonce) + 1n;
@@ -224,13 +229,13 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
             for (let i = 0; i < txs.length; i++) {
                 let tx;
                 if (signer.signTransaction == null) {
-                    const txId = await signer.sendTransaction(txs[i], onBeforePublish);
+                    const txId = await signer.sendTransaction(txs[i], txs[i].addedInPrepare ? undefined : onBeforePublish);
                     tx = txs[i];
                     tx.txId = txId;
                 }
                 else {
                     const signedTx = signedTxs[i];
-                    await this.sendSignedTransaction(signedTx, onBeforePublish);
+                    await this.sendSignedTransaction(signedTx, signedTx.addedInPrepare ? undefined : onBeforePublish);
                     tx = signedTx;
                 }
                 if (tx.details.nonce != null) {
@@ -240,9 +245,11 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
                         this.latestPendingNonces[(0, Utils_1.toHex)(tx.details.walletAddress)] = nextAccountNonce;
                     }
                 }
-                promises.push(this.confirmTransaction(tx, abortSignal));
-                if (!waitForConfirmation)
-                    txIds.push(tx.txId);
+                if (!tx.addedInPrepare) {
+                    promises.push(this.confirmTransaction(tx, abortSignal));
+                    if (!waitForConfirmation)
+                        txIds.push(tx.txId);
+                }
                 this.logger.debug("sendAndConfirm(): transaction sent (" + (i + 1) + "/" + txs.length + "): " + tx.txId);
                 if (promises.length >= MAX_UNCONFIRMED_TXS) {
                     if (waitForConfirmation)
@@ -258,13 +265,13 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
             for (let i = 0; i < txs.length; i++) {
                 let tx;
                 if (signer.signTransaction == null) {
-                    const txId = await signer.sendTransaction(txs[i], onBeforePublish);
+                    const txId = await signer.sendTransaction(txs[i], txs[i].addedInPrepare ? undefined : onBeforePublish);
                     tx = txs[i];
                     tx.txId = txId;
                 }
                 else {
                     const signedTx = signedTxs[i];
-                    await this.sendSignedTransaction(signedTx, onBeforePublish);
+                    await this.sendSignedTransaction(signedTx, signedTx.addedInPrepare ? undefined : onBeforePublish);
                     tx = signedTx;
                 }
                 if (tx.details.nonce != null) {
@@ -280,7 +287,8 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
                 let txHash = tx.txId;
                 if (i < txs.length - 1 || waitForConfirmation)
                     txHash = await confirmPromise;
-                txIds.push(txHash);
+                if (!tx.addedInPrepare)
+                    txIds.push(txHash);
             }
         }
         this.logger.info("sendAndConfirm(): sent transactions, count: " + txs.length +

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.35",
+  "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/chain/modules/StarknetTransactions.ts

@@ -167,7 +167,7 @@ export class StarknetTransactions extends StarknetModule {
      * @param txs
      * @private
      */
-    private async prepareTransactions(signer: StarknetSigner, txs: StarknetTx[]): Promise<void> {
+    private async prepareTransactions(signer: StarknetSigner, txs: (StarknetTx & {addedInPrepare?: boolean})[]): Promise<void> {
         let nonce: bigint = await this.getNonce(signer.getAddress());
         const latestPendingNonce = this.latestPendingNonces[toHex(signer.getAddress())];
         if(latestPendingNonce!=null && latestPendingNonce > nonce) {
@@ -178,7 +178,11 @@ export class StarknetTransactions extends StarknetModule {
         //Add deploy account tx
         if(nonce===0n) {
             const deployPayload = await signer.getDeployPayload();
-            if(deployPayload!=null) txs.unshift(await this.root.Accounts.getAccountDeployTransaction(deployPayload));
+            if(deployPayload!=null) {
+                const tx: (StarknetTx & {addedInPrepare?: boolean}) = await this.root.Accounts.getAccountDeployTransaction(deployPayload);
+                tx.addedInPrepare = true;
+                txs.unshift(tx);
+            }
         }
 
         if(!signer.isManagingNoncesInternally) {
@@ -193,7 +197,7 @@ export class StarknetTransactions extends StarknetModule {
                 if(nonce==null) nonce = BigInt(await this.root.provider.getNonceForAddress(signer.getAddress())); //Fetch the nonce
                 if(tx.details.nonce==null) tx.details.nonce = nonce;
 
-                this.logger.debug("sendAndConfirm(): transaction prepared ("+(i+1)+"/"+txs.length+"), nonce: "+tx.details.nonce);
+                this.logger.debug("prepareTransactions(): transaction prepared ("+(i+1)+"/"+txs.length+"), nonce: "+tx.details.nonce);
 
                 nonce += BigInt(1);
             }
@@ -231,7 +235,7 @@ export class StarknetTransactions extends StarknetModule {
      *  of a batch of starknet transactions
      *
      * @param signer
-     * @param txs transactions to send
+     * @param _txs transactions to send
      * @param waitForConfirmation whether to wait for transaction confirmations (this also makes sure the transactions
      *  are re-sent at regular intervals)
      * @param abortSignal abort signal to abort waiting for transaction confirmations
@@ -239,14 +243,16 @@ export class StarknetTransactions extends StarknetModule {
      *  are executed in order)
      * @param onBeforePublish a callback called before every transaction is published
      */
-    public async sendAndConfirm(signer: StarknetSigner, txs: StarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]> {
+    public async sendAndConfirm(signer: StarknetSigner, _txs: StarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]> {
+        const txs: (StarknetTx & {addedInPrepare?: boolean})[] = _txs;
         await this.prepareTransactions(signer, txs);
-        const signedTxs: StarknetTx[] = [];
+        const signedTxs: (StarknetTx & {addedInPrepare?: boolean})[] = [];
 
         //Don't separate the signing process from the sending when using browser-based wallet
         if(signer.signTransaction!=null) for(let i=0;i<txs.length;i++) {
             const tx = txs[i];
-            const signedTx = await signer.signTransaction(tx);
+            const signedTx: (StarknetTx & {addedInPrepare?: boolean}) = await signer.signTransaction(tx);
+            signedTx.addedInPrepare = tx.addedInPrepare;
             signedTxs.push(signedTx);
             this.logger.debug("sendAndConfirm(): transaction signed ("+(i+1)+"/"+txs.length+"): "+signedTx.txId);
 
@@ -264,14 +270,14 @@ export class StarknetTransactions extends StarknetModule {
         if(parallel) {
             let promises: Promise<string>[] = [];
             for(let i=0;i<txs.length;i++) {
-                let tx: StarknetTx;
+                let tx: (StarknetTx & {addedInPrepare?: boolean});
                 if(signer.signTransaction==null) {
-                    const txId = await signer.sendTransaction(txs[i], onBeforePublish);
+                    const txId = await signer.sendTransaction(txs[i], txs[i].addedInPrepare ? undefined : onBeforePublish);
                     tx = txs[i];
                     tx.txId = txId;
                 } else {
                     const signedTx = signedTxs[i];
-                    await this.sendSignedTransaction(signedTx, onBeforePublish);
+                    await this.sendSignedTransaction(signedTx, signedTx.addedInPrepare ? undefined : onBeforePublish);
                     tx = signedTx;
                 }
 
@@ -283,8 +289,10 @@ export class StarknetTransactions extends StarknetModule {
                     }
                 }
 
-                promises.push(this.confirmTransaction(tx, abortSignal));
-                if(!waitForConfirmation) txIds.push(tx.txId);
+                if(!tx.addedInPrepare) {
+                    promises.push(this.confirmTransaction(tx, abortSignal));
+                    if(!waitForConfirmation) txIds.push(tx.txId);
+                }
                 this.logger.debug("sendAndConfirm(): transaction sent ("+(i+1)+"/"+txs.length+"): "+tx.txId);
                 if(promises.length >= MAX_UNCONFIRMED_TXS) {
                     if(waitForConfirmation) txIds.push(...await Promise.all(promises));
@@ -296,14 +304,14 @@ export class StarknetTransactions extends StarknetModule {
             }
         } else {
             for(let i=0;i<txs.length;i++) {
-                let tx: StarknetTx;
+                let tx: (StarknetTx & {addedInPrepare?: boolean});
                 if(signer.signTransaction==null) {
-                    const txId = await signer.sendTransaction(txs[i], onBeforePublish);
+                    const txId = await signer.sendTransaction(txs[i], txs[i].addedInPrepare ? undefined : onBeforePublish);
                     tx = txs[i];
                     tx.txId = txId;
                 } else {
                     const signedTx = signedTxs[i];
-                    await this.sendSignedTransaction(signedTx, onBeforePublish);
+                    await this.sendSignedTransaction(signedTx, signedTx.addedInPrepare ? undefined : onBeforePublish);
                     tx = signedTx;
                 }
 
@@ -320,7 +328,7 @@ export class StarknetTransactions extends StarknetModule {
                 //Don't await the last promise when !waitForConfirmation
                 let txHash = tx.txId;
                 if(i<txs.length-1 || waitForConfirmation) txHash = await confirmPromise;
-                txIds.push(txHash);
+                if(!tx.addedInPrepare) txIds.push(txHash);
             }
         }
 

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;
     }