@atomiqlabs/chain-evm 1.0.0-dev.99 → 1.0.0

package/dist/chains/botanix/BotanixInitializer.d.ts

@@ -23,7 +23,7 @@ export type BotanixOptions = {
         };
     };
     fees?: EVMFees;
-    evmConfig?: Omit<EVMConfiguration, "safeBlockTag">;
+    evmConfig?: Omit<EVMConfiguration, "safeBlockTag" | "finalizedBlockTag">;
 };
 export declare function initializeBotanix(options: BotanixOptions, bitcoinRpc: BitcoinRpc<any>, network: BitcoinNetwork): ChainData<BotanixChainType>;
 export type BotanixInitializerType = ChainInitializer<BotanixOptions, BotanixChainType, BotanixAssetsType>;

package/dist/chains/botanix/BotanixInitializer.js

@@ -84,6 +84,7 @@ function initializeBotanix(options, bitcoinRpc, network) {
     const Fees = options.fees ?? new EVMFees_1.EVMFees(provider, 2n * 1000000000n, 1000000n);
     const chainInterface = new EVMChainInterface_1.EVMChainInterface("BOTANIX", chainId, provider, {
         safeBlockTag: "finalized",
+        finalizedBlockTag: "finalized",
         maxLogsBlockRange: options?.evmConfig?.maxLogsBlockRange ?? 950,
         maxLogTopics: options?.evmConfig?.maxLogTopics ?? 64,
         maxParallelLogRequests: options?.evmConfig?.maxParallelLogRequests ?? 5,

package/dist/chains/citrea/CitreaInitializer.d.ts

@@ -23,7 +23,7 @@ export type CitreaOptions = {
         };
     };
     fees?: CitreaFees;
-    evmConfig?: Omit<EVMConfiguration, "safeBlockTag">;
+    evmConfig?: Omit<EVMConfiguration, "safeBlockTag" | "finalizedBlockTag">;
 };
 export declare function initializeCitrea(options: CitreaOptions, bitcoinRpc: BitcoinRpc<any>, network: BitcoinNetwork): ChainData<CitreaChainType>;
 export type CitreaInitializerType = ChainInitializer<CitreaOptions, CitreaChainType, CitreaAssetsType>;

package/dist/chains/citrea/CitreaInitializer.js

@@ -90,6 +90,7 @@ function initializeCitrea(options, bitcoinRpc, network) {
     const Fees = options.fees ?? new CitreaFees_1.CitreaFees(provider, 2n * 1000000000n, 1000000n);
     const chainInterface = new EVMChainInterface_1.EVMChainInterface("CITREA", chainId, provider, {
         safeBlockTag: "latest",
+        finalizedBlockTag: "safe",
         maxLogsBlockRange: options?.evmConfig?.maxLogsBlockRange ?? 950,
         maxLogTopics: options?.evmConfig?.maxLogTopics ?? 64,
         maxParallelLogRequests: options?.evmConfig?.maxParallelLogRequests ?? 5,

package/dist/evm/chain/EVMChainInterface.d.ts

@@ -15,6 +15,7 @@ export type EVMRetryPolicy = {
 };
 export type EVMConfiguration = {
     safeBlockTag: EVMBlockTag;
+    finalizedBlockTag: EVMBlockTag;
     maxLogsBlockRange: number;
     maxParallelLogRequests: number;
     maxParallelCalls: number;
@@ -50,6 +51,10 @@ export declare class EVMChainInterface<ChainId extends string = string> implemen
     deserializeTx(txData: string): Promise<Transaction>;
     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<TransactionRequest[]>;
     transfer(signer: EVMSigner, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
     wrapSigner(signer: Signer): Promise<EVMSigner>;

package/dist/evm/chain/EVMChainInterface.js

@@ -14,13 +14,14 @@ const EVMSigner_1 = require("../wallet/EVMSigner");
 const EVMBrowserSigner_1 = require("../wallet/EVMBrowserSigner");
 class EVMChainInterface {
     constructor(chainId, evmChainId, provider, config, retryPolicy, evmFeeEstimator = new EVMFees_1.EVMFees(provider)) {
-        var _a;
+        var _a, _b;
         this.chainId = chainId;
         this.evmChainId = evmChainId;
         this.provider = provider;
         this.retryPolicy = retryPolicy;
         this.config = config;
         (_a = this.config).safeBlockTag ?? (_a.safeBlockTag = "safe");
+        (_b = this.config).finalizedBlockTag ?? (_b.finalizedBlockTag = "finalized");
         this.logger = (0, Utils_1.getLogger)("EVMChainInterface(" + this.evmChainId + "): ");
         this.Fees = evmFeeEstimator;
         this.Tokens = new EVMTokens_1.EVMTokens(this);
@@ -81,6 +82,13 @@ class EVMChainInterface {
     getTxStatus(tx) {
         return this.Transactions.getTxStatus(tx);
     }
+    async getFinalizedBlock() {
+        const block = await this.Blocks.getBlock(this.config.finalizedBlockTag);
+        return {
+            height: block.number,
+            blockHash: block.hash
+        };
+    }
     async txsTransfer(signer, token, amount, dstAddress, feeRate) {
         return [await this.Tokens.Transfer(signer, token, amount, dstAddress, feeRate)];
     }

package/dist/evm/chain/modules/EVMBlocks.d.ts

@@ -1,4 +1,5 @@
 import { EVMModule } from "../EVMModule";
+import { Block } from "ethers";
 export type EVMBlockTag = "safe" | "pending" | "latest" | "finalized";
 export declare class EVMBlocks extends EVMModule<any> {
     private BLOCK_CACHE_TIME;
@@ -16,5 +17,11 @@ export declare class EVMBlocks extends EVMModule<any> {
      *
      * @param blockTag
      */
+    getBlock(blockTag: EVMBlockTag | number): Promise<Block>;
+    /**
+     * Gets the block time for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
     getBlockTime(blockTag: EVMBlockTag | number): Promise<number>;
 }

package/dist/evm/chain/modules/EVMBlocks.js

@@ -16,19 +16,19 @@ class EVMBlocks extends EVMModule_1.EVMModule {
      */
     fetchAndSaveBlockTime(blockTag) {
         const blockTagStr = blockTag.toString(10);
-        const blockTimePromise = this.provider.getBlock(blockTag, false).then(result => result.timestamp);
+        const blockPromise = this.provider.getBlock(blockTag, false);
         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 EVMBlocks extends EVMModule_1.EVMModule {
      *
      * @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 time for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    async getBlockTime(blockTag) {
+        const block = await this.getBlock(blockTag);
+        return block.timestamp;
     }
 }
 exports.EVMBlocks = EVMBlocks;

package/dist/evm/chain/modules/EVMEvents.js

@@ -22,7 +22,8 @@ class EVMEvents extends EVMModule_1.EVMModule {
             });
         }
         catch (e) {
-            if (e.error?.code === -32008 || //Response is too big
+            if ((e.error?.code === -32602 && e.error?.message?.startsWith("query exceeds max results")) || //Query exceeds max results
+                e.error?.code === -32008 || //Response is too big
                 e.error?.code === -32005 //Limit exceeded
             ) {
                 if (startBlock === endBlock)

package/dist/evm/chain/modules/EVMTransactions.js

@@ -4,6 +4,7 @@ exports.EVMTransactions = void 0;
 const EVMModule_1 = require("../EVMModule");
 const ethers_1 = require("ethers");
 const Utils_1 = require("../../../utils/Utils");
+const base_1 = require("@atomiqlabs/base");
 const MAX_UNCONFIRMED_TXNS = 10;
 class EVMTransactions extends EVMModule_1.EVMModule {
     constructor() {
@@ -68,7 +69,7 @@ class EVMTransactions extends EVMModule_1.EVMModule {
             this.latestConfirmedNonces[tx.from] = nextAccountNonce;
         }
         if (state === "reverted")
-            throw new Error("Transaction reverted!");
+            throw new base_1.TransactionRevertedError("Transaction reverted!");
         return confirmedTxId;
     }
     /**

package/dist/evm/contract/modules/EVMContractEvents.d.ts

@@ -36,7 +36,8 @@ export declare class EVMContractEvents<T extends BaseContract> extends EVMEvents
      * @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<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: (string | string[])[], processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>, abortSignal?: AbortSignal): Promise<TResult>;
+    findInContractEventsForward<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: (string | string[])[], processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>, startHeight?: number, abortSignal?: AbortSignal): Promise<TResult>;
 }

package/dist/evm/contract/modules/EVMContractEvents.js

@@ -59,9 +59,10 @@ class EVMContractEvents extends EVMEvents_1.EVMEvents {
      * @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(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events) => {
             const parsedEvents = this.toTypedEvents(events);
             for (let event of parsedEvents) {
@@ -69,7 +70,7 @@ class EVMContractEvents extends EVMEvents_1.EVMEvents {
                 if (result != null)
                     return result;
             }
-        }, abortSignal, this.contract.contractDeploymentHeight);
+        }, abortSignal, Math.max(this.contract.contractDeploymentHeight, startHeight ?? 0));
     }
 }
 exports.EVMContractEvents = EVMContractEvents;

package/dist/evm/providers/ReconnectingWebSocketProvider.js

@@ -36,7 +36,7 @@ class ReconnectingWebSocketProvider extends SocketProvider_1.SocketProvider {
             logger.info("connect(): Websocket connected!");
         };
         this.websocket.onerror = (err) => {
-            logger.error(`connect(): onerror: Websocket connection error: `, err);
+            logger.error(`connect(): onerror: Websocket connection error: `, err.error ?? err);
             this.disconnectedAndScheduleReconnect();
         };
         this.websocket.onmessage = (message) => {
@@ -59,7 +59,7 @@ class ReconnectingWebSocketProvider extends SocketProvider_1.SocketProvider {
             return;
         this.websocket.onclose = null;
         //Register dummy handler, otherwise we get unhandled `error` event which crashes the whole thing
-        this.websocket.onerror = (err) => logger.error("disconnectedAndScheduleReconnect(): Post-close onerror: ", err);
+        this.websocket.onerror = (err) => logger.error("disconnectedAndScheduleReconnect(): Post-close onerror: ", err.error ?? err);
         this.websocket.onmessage = null;
         this.websocket.onopen = null;
         this.websocket = null;

package/dist/evm/spv_swap/EVMSpvVaultContract.d.ts

@@ -40,7 +40,7 @@ export declare class EVMSpvVaultContract<ChainId extends string> extends EVMCont
     protected Claim(signer: string, vault: EVMSpvVaultData, data: EVMSpvWithdrawalData, blockheader: EVMBtcStoredHeader, merkle: Buffer[], position: number, feeRate: string): Promise<TransactionRequest>;
     checkWithdrawalTx(tx: SpvWithdrawalTransactionData): Promise<void>;
     createVaultData(owner: string, vaultId: bigint, utxo: string, confirmations: number, tokenData: SpvVaultTokenData[]): Promise<EVMSpvVaultData>;
-    getFronterAddress(owner: string, vaultId: bigint, withdrawal: EVMSpvWithdrawalData): Promise<string>;
+    getFronterAddress(owner: string, vaultId: bigint, withdrawal: EVMSpvWithdrawalData): Promise<string | null>;
     getFronterAddresses(withdrawals: {
         owner: string;
         vaultId: bigint;
@@ -69,8 +69,11 @@ export declare class EVMSpvVaultContract<ChainId extends string> extends EVMCont
     }>;
     getAllVaults(owner?: string): Promise<EVMSpvVaultData[]>;
     private parseWithdrawalEvent;
-    getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState>;
-    getWithdrawalStates(btcTxIds: string[]): Promise<{
+    getWithdrawalState(withdrawalTx: EVMSpvWithdrawalData, scStartHeight?: number): Promise<SpvWithdrawalState>;
+    getWithdrawalStates(withdrawalTxs: {
+        withdrawal: EVMSpvWithdrawalData;
+        scStartBlockheight?: number;
+    }[]): Promise<{
         [btcTxId: string]: SpvWithdrawalState;
     }>;
     getWithdrawalData(btcTx: BtcTx): Promise<EVMSpvWithdrawalData>;

package/dist/evm/spv_swap/EVMSpvVaultContract.js

@@ -262,49 +262,100 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
                 return null;
         }
     }
-    async getWithdrawalState(btcTxId) {
-        const txHash = buffer_1.Buffer.from(btcTxId, "hex").reverse();
-        let result = await this.Events.findInContractEvents(["Fronted", "Claimed", "Closed"], [
-            null,
-            null,
-            (0, ethers_1.hexlify)(txHash)
-        ], async (event) => {
-            const result = this.parseWithdrawalEvent(event);
-            if (result != null)
+    async getWithdrawalState(withdrawalTx, scStartHeight) {
+        const txHash = buffer_1.Buffer.from(withdrawalTx.getTxId(), "hex").reverse();
+        const events = ["Fronted", "Claimed", "Closed"];
+        const keys = [null, null, (0, ethers_1.hexlify)(txHash)];
+        let result;
+        if (scStartHeight == null) {
+            result = await this.Events.findInContractEvents(events, keys, async (event) => {
+                const result = this.parseWithdrawalEvent(event);
+                if (result != null)
+                    return result;
+            });
+        }
+        else {
+            result = await this.Events.findInContractEventsForward(events, keys, async (event) => {
+                const result = this.parseWithdrawalEvent(event);
+                if (result == null)
+                    return;
+                if (result.type === base_1.SpvWithdrawalStateType.FRONTED) {
+                    //Check if still fronted
+                    const fronterAddress = await this.getFronterAddress(result.owner, result.vaultId, withdrawalTx);
+                    //Not fronted now, there should be a claim/close event after the front event, continue
+                    if (fronterAddress == null)
+                        return;
+                }
                 return result;
-        });
+            }, scStartHeight);
+        }
         result ?? (result = {
             type: base_1.SpvWithdrawalStateType.NOT_FOUND
         });
         return result;
     }
-    async getWithdrawalStates(btcTxIds) {
+    async getWithdrawalStates(withdrawalTxs) {
+        var _a;
         const result = {};
-        for (let i = 0; i < btcTxIds.length; i += this.Chain.config.maxLogTopics) {
-            const checkBtcTxIds = btcTxIds.slice(i, i + this.Chain.config.maxLogTopics);
-            const checkBtcTxIdsSet = new Set(checkBtcTxIds);
-            await this.Events.findInContractEvents(["Fronted", "Claimed", "Closed"], [
-                null,
-                null,
-                checkBtcTxIds.map(btcTxId => (0, ethers_1.hexlify)(buffer_1.Buffer.from(btcTxId, "hex").reverse()))
-            ], async (event) => {
-                const _event = event;
-                const btcTxId = buffer_1.Buffer.from(_event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
-                if (!checkBtcTxIdsSet.has(btcTxId)) {
-                    this.logger.warn(`getWithdrawalStates(): findInContractEvents-callback: loaded event for ${btcTxId}, but transaction not found in input params!`);
-                    return null;
+        const events = ["Fronted", "Claimed", "Closed"];
+        for (let i = 0; i < withdrawalTxs.length; i += this.Chain.config.maxLogTopics) {
+            const checkWithdrawalTxs = withdrawalTxs.slice(i, i + this.Chain.config.maxLogTopics);
+            const checkWithdrawalTxsMap = new Map(checkWithdrawalTxs.map(val => [val.withdrawal.getTxId(), val.withdrawal]));
+            let scStartHeight = null;
+            for (let val of checkWithdrawalTxs) {
+                if (val.scStartBlockheight == null) {
+                    scStartHeight = null;
+                    break;
                 }
-                const eventResult = this.parseWithdrawalEvent(event);
-                if (eventResult == null)
-                    return null;
-                checkBtcTxIdsSet.delete(btcTxId);
-                result[btcTxId] = eventResult;
-                if (checkBtcTxIdsSet.size === 0)
-                    return true; //All processed
-            });
+                scStartHeight = Math.min(scStartHeight ?? Infinity, val.scStartBlockheight);
+            }
+            const keys = [null, null, checkWithdrawalTxs.map(withdrawal => (0, ethers_1.hexlify)(buffer_1.Buffer.from(withdrawal.withdrawal.getTxId(), "hex").reverse()))];
+            if (scStartHeight == null) {
+                await this.Events.findInContractEvents(events, keys, async (event) => {
+                    const _event = event;
+                    const btcTxId = buffer_1.Buffer.from(_event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
+                    if (!checkWithdrawalTxsMap.has(btcTxId)) {
+                        this.logger.warn(`getWithdrawalStates(): findInContractEvents-callback: loaded event for ${btcTxId}, but transaction not found in input params!`);
+                        return null;
+                    }
+                    const eventResult = this.parseWithdrawalEvent(event);
+                    if (eventResult == null)
+                        return null;
+                    checkWithdrawalTxsMap.delete(btcTxId);
+                    result[btcTxId] = eventResult;
+                    if (checkWithdrawalTxsMap.size === 0)
+                        return true; //All processed
+                });
+            }
+            else {
+                await this.Events.findInContractEventsForward(events, keys, async (event) => {
+                    const _event = event;
+                    const btcTxId = buffer_1.Buffer.from(_event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
+                    const withdrawalTx = checkWithdrawalTxsMap.get(btcTxId);
+                    if (withdrawalTx == null) {
+                        this.logger.warn(`getWithdrawalStates(): findInContractEvents-callback: loaded event for ${btcTxId}, but transaction not found in input params!`);
+                        return;
+                    }
+                    const eventResult = this.parseWithdrawalEvent(event);
+                    if (eventResult == null)
+                        return;
+                    if (eventResult.type === base_1.SpvWithdrawalStateType.FRONTED) {
+                        //Check if still fronted
+                        const fronterAddress = await this.getFronterAddress(eventResult.owner, eventResult.vaultId, withdrawalTx);
+                        //Not fronted now, so there should be a claim/close event after the front event, continue
+                        if (fronterAddress == null)
+                            return;
+                        //Fronted still, so this should be the latest current state
+                    }
+                    checkWithdrawalTxsMap.delete(btcTxId);
+                    result[btcTxId] = eventResult;
+                    if (checkWithdrawalTxsMap.size === 0)
+                        return true; //All processed
+                }, scStartHeight);
+            }
         }
-        for (let btcTxId of btcTxIds) {
-            result[btcTxId] ?? (result[btcTxId] = {
+        for (let val of withdrawalTxs) {
+            result[_a = val.withdrawal.getTxId()] ?? (result[_a] = {
                 type: base_1.SpvWithdrawalStateType.NOT_FOUND
             });
         }

package/dist/evm/wallet/EVMPersistentSigner.d.ts

@@ -22,6 +22,7 @@ export declare class EVMPersistentSigner extends EVMSigner {
     private save;
     private checkPastTransactions;
     private startFeeBumper;
+    private syncNonceFromChain;
     init(): Promise<void>;
     stop(): Promise<void>;
     private readonly sendTransactionQueue;

package/dist/evm/wallet/EVMPersistentSigner.js

@@ -74,12 +74,14 @@ class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
         let _safeBlockTxCount = null;
         for (let [nonce, data] of this.pendingTxs) {
             if (!data.sending && data.lastBumped < Date.now() - this.waitBeforeBump) {
-                _safeBlockTxCount = await this.chainInterface.provider.getTransactionCount(this.address, this.safeBlockTag);
-                this.confirmedNonce = _safeBlockTxCount;
-                if (_safeBlockTxCount > nonce) {
+                if (_safeBlockTxCount == null) {
+                    _safeBlockTxCount = await this.chainInterface.provider.getTransactionCount(this.address, this.safeBlockTag);
+                    this.confirmedNonce = _safeBlockTxCount - 1;
+                }
+                if (this.confirmedNonce >= nonce) {
                     this.pendingTxs.delete(nonce);
                     data.txs.forEach(tx => this.chainInterface.Transactions._knownTxSet.delete(tx.hash));
-                    this.logger.info("checkPastTransactions(): Tx confirmed, required fee bumps: ", data.txs.length);
+                    this.logger.info(`checkPastTransactions(): Tx confirmed, nonce: ${nonce}, required fee bumps: `, data.txs.length);
                     this.save();
                     continue;
                 }
@@ -159,6 +161,22 @@ class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
         };
         func();
     }
+    async syncNonceFromChain() {
+        const txCount = await this.chainInterface.provider.getTransactionCount(this.address, this.safeBlockTag);
+        this.confirmedNonce = txCount - 1;
+        if (this.pendingNonce < this.confirmedNonce) {
+            this.logger.info(`syncNonceFromChain(): Re-synced latest nonce from chain, adjusting local pending nonce ${this.pendingNonce} -> ${this.confirmedNonce}`);
+            this.pendingNonce = this.confirmedNonce;
+            for (let [nonce, data] of this.pendingTxs) {
+                if (nonce <= this.pendingNonce) {
+                    this.pendingTxs.delete(nonce);
+                    data.txs.forEach(tx => this.chainInterface.Transactions._knownTxSet.delete(tx.hash));
+                    this.logger.info(`syncNonceFromChain(): Tx confirmed, nonce: ${nonce}, required fee bumps: `, data.txs.length);
+                }
+            }
+            this.save();
+        }
+    }
     async init() {
         try {
             await fs.mkdir(this.directory);
@@ -213,11 +231,18 @@ class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
             this.save();
             this.chainInterface.Transactions._knownTxSet.add(signedTx.hash);
             try {
+                //TODO: This can fail due to not receiving a response from the server, however the transaction
+                // might already be broadcasted!
                 const result = await this.chainInterface.provider.broadcastTransaction(signedRawTx);
                 pendingTxObject.sending = false;
                 return result;
             }
             catch (e) {
+                if (e.code === "NONCE_EXPIRED") {
+                    //Re-check nonce from on-chain
+                    this.logger.info("sendTransaction(): Got NONCE_EXPIRED back from backend, re-checking latest nonce from chain!");
+                    await this.syncNonceFromChain();
+                }
                 this.chainInterface.Transactions._knownTxSet.delete(signedTx.hash);
                 this.pendingTxs.delete(transaction.nonce);
                 this.pendingNonce--;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-evm",
-  "version": "1.0.0-dev.99",
+  "version": "1.0.0",
   "description": "EVM specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
   "author": "adambor",
   "license": "Apache-2.0",
   "dependencies": {
-    "@atomiqlabs/base": "^10.0.0-dev.18",
+    "@atomiqlabs/base": "^10.0.0-dev.21",
     "@noble/hashes": "^1.8.0",
     "@scure/btc-signer": "^1.6.0",
     "buffer": "6.0.3",

package/src/chains/botanix/BotanixInitializer.ts

@@ -87,7 +87,7 @@ export type BotanixOptions = {
 
     fees?: EVMFees,
 
-    evmConfig?: Omit<EVMConfiguration, "safeBlockTag">
+    evmConfig?: Omit<EVMConfiguration, "safeBlockTag" | "finalizedBlockTag">
 }
 
 export function initializeBotanix(
@@ -121,6 +121,7 @@ export function initializeBotanix(
 
     const chainInterface = new EVMChainInterface("BOTANIX", chainId, provider, {
         safeBlockTag: "finalized",
+        finalizedBlockTag: "finalized",
         maxLogsBlockRange: options?.evmConfig?.maxLogsBlockRange ?? 950,
         maxLogTopics: options?.evmConfig?.maxLogTopics ?? 64,
         maxParallelLogRequests: options?.evmConfig?.maxParallelLogRequests ?? 5,

package/src/chains/citrea/CitreaInitializer.ts

@@ -93,7 +93,7 @@ export type CitreaOptions = {
 
     fees?: CitreaFees,
 
-    evmConfig?: Omit<EVMConfiguration, "safeBlockTag">
+    evmConfig?: Omit<EVMConfiguration, "safeBlockTag" | "finalizedBlockTag">
 }
 
 export function initializeCitrea(
@@ -127,6 +127,7 @@ export function initializeCitrea(
 
     const chainInterface = new EVMChainInterface("CITREA", chainId, provider, {
         safeBlockTag: "latest",
+        finalizedBlockTag: "safe",
         maxLogsBlockRange: options?.evmConfig?.maxLogsBlockRange ?? 950,
         maxLogTopics: options?.evmConfig?.maxLogTopics ?? 64,
         maxParallelLogRequests: options?.evmConfig?.maxParallelLogRequests ?? 5,

package/src/evm/chain/EVMChainInterface.ts

@@ -28,6 +28,7 @@ export type EVMRetryPolicy = {
 
 export type EVMConfiguration = {
     safeBlockTag: EVMBlockTag,
+    finalizedBlockTag: EVMBlockTag,
     maxLogsBlockRange: number,
     maxParallelLogRequests: number,
     maxParallelCalls: number,
@@ -68,6 +69,7 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
         this.retryPolicy = retryPolicy;
         this.config = config;
         this.config.safeBlockTag ??= "safe";
+        this.config.finalizedBlockTag ??= "finalized";
 
         this.logger = getLogger("EVMChainInterface("+this.evmChainId+"): ");
 
@@ -154,6 +156,14 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
         return this.Transactions.getTxStatus(tx);
     }
 
+    async getFinalizedBlock(): Promise<{ height: number; blockHash: string }> {
+        const block = await this.Blocks.getBlock(this.config.finalizedBlockTag);
+        return {
+            height: block.number,
+            blockHash: block.hash
+        };
+    }
+
     async txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<TransactionRequest[]> {
         return [await this.Tokens.Transfer(signer, token, amount, dstAddress, feeRate)];
     }

package/src/evm/chain/modules/EVMBlocks.ts

@@ -1,4 +1,5 @@
 import {EVMModule} from "../EVMModule";
+import {Block} from "ethers";
 
 export type EVMBlockTag = "safe" | "pending" | "latest" | "finalized";
 
@@ -8,7 +9,7 @@ export class EVMBlocks extends EVMModule<any> {
 
     private blockCache: {
         [key: string]: {
-            blockTime: Promise<number>,
+            block: Promise<Block>,
             timestamp: number
         }
     } = {};
@@ -20,23 +21,23 @@ export class EVMBlocks extends EVMModule<any> {
      * @param blockTag
      */
     private fetchAndSaveBlockTime(blockTag: EVMBlockTag | number): {
-        blockTime: Promise<number>,
+        block: Promise<Block>,
         timestamp: number
     } {
         const blockTagStr = blockTag.toString(10);
 
-        const blockTimePromise = this.provider.getBlock(blockTag, false).then(result => result.timestamp);
+        const blockPromise = this.provider.getBlock(blockTag, false);
         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
         };
     }
@@ -61,7 +62,7 @@ export class EVMBlocks extends EVMModule<any> {
      *
      * @param blockTag
      */
-    public getBlockTime(blockTag: EVMBlockTag | number): Promise<number> {
+    public getBlock(blockTag: EVMBlockTag | number): Promise<Block> {
         this.cleanupBlocks();
         let cachedBlockData = this.blockCache[blockTag.toString(10)];
 
@@ -69,7 +70,17 @@ export class EVMBlocks extends EVMModule<any> {
             cachedBlockData = this.fetchAndSaveBlockTime(blockTag);
         }
 
-        return cachedBlockData.blockTime;
+        return cachedBlockData.block;
+    }
+
+    /**
+     * Gets the block time for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    public async getBlockTime(blockTag: EVMBlockTag | number): Promise<number> {
+        const block = await this.getBlock(blockTag);
+        return block.timestamp;
     }
 
 }

package/src/evm/chain/modules/EVMEvents.ts

@@ -24,6 +24,7 @@ export class EVMEvents extends EVMModule<any> {
             });
         } catch (e) {
             if(
+                (e.error?.code===-32602 && e.error?.message?.startsWith("query exceeds max results")) || //Query exceeds max results
                 e.error?.code===-32008 || //Response is too big
                 e.error?.code===-32005 //Limit exceeded
             ) {

package/src/evm/chain/modules/EVMTransactions.ts

@@ -2,6 +2,7 @@ import {EVMModule} from "../EVMModule";
 import {Transaction, TransactionRequest, TransactionResponse} from "ethers";
 import {timeoutPromise} from "../../../utils/Utils";
 import {EVMSigner} from "../../wallet/EVMSigner";
+import {TransactionRevertedError} from "@atomiqlabs/base";
 
 export type EVMTx = TransactionRequest;
 
@@ -87,7 +88,7 @@ export class EVMTransactions extends EVMModule<any> {
         if(currentConfirmedNonce==null || nextAccountNonce > currentConfirmedNonce) {
             this.latestConfirmedNonces[tx.from] = nextAccountNonce;
         }
-        if(state==="reverted") throw new Error("Transaction reverted!");
+        if(state==="reverted") throw new TransactionRevertedError("Transaction reverted!");
 
         return confirmedTxId;
     }

package/src/evm/contract/modules/EVMContractEvents.ts

@@ -81,12 +81,14 @@ export class EVMContractEvents<T extends BaseContract> extends EVMEvents {
      * @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<TResult, TEventName extends keyof T["filters"]>(
         events: TEventName[],
         keys: (string | string[])[],
         processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>,
+        startHeight?: number,
         abortSignal?: AbortSignal
     ): Promise<TResult> {
         return this.findInEventsForward<TResult>(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events: Log[]) => {
@@ -95,7 +97,7 @@ export class EVMContractEvents<T extends BaseContract> extends EVMEvents {
                 const result: TResult = await processor(event);
                 if(result!=null) return result;
             }
-        }, abortSignal, this.contract.contractDeploymentHeight);
+        }, abortSignal, Math.max(this.contract.contractDeploymentHeight, startHeight ?? 0));
     }
 
 }

package/src/evm/providers/ReconnectingWebSocketProvider.ts

@@ -51,7 +51,7 @@ export class ReconnectingWebSocketProvider extends SocketProvider {
         };
 
         this.websocket.onerror = (err) => {
-            logger.error(`connect(): onerror: Websocket connection error: `, err);
+            logger.error(`connect(): onerror: Websocket connection error: `, err.error ?? err);
             this.disconnectedAndScheduleReconnect();
         };
 
@@ -76,7 +76,7 @@ export class ReconnectingWebSocketProvider extends SocketProvider {
         if(this.websocket==null) return;
         this.websocket.onclose = null;
         //Register dummy handler, otherwise we get unhandled `error` event which crashes the whole thing
-        this.websocket.onerror = (err) => logger.error("disconnectedAndScheduleReconnect(): Post-close onerror: ", err);
+        this.websocket.onerror = (err) => logger.error("disconnectedAndScheduleReconnect(): Post-close onerror: ", err.error ?? err);
         this.websocket.onmessage = null;
         this.websocket.onopen = null;
         this.websocket = null;

package/src/evm/spv_swap/EVMSpvVaultContract.ts

@@ -11,9 +11,9 @@ import {
     TransactionConfirmationOptions
 } from "@atomiqlabs/base";
 import {Buffer} from "buffer";
-import { EVMTx } from "../chain/modules/EVMTransactions";
-import { EVMContractBase } from "../contract/EVMContractBase";
-import { EVMSigner } from "../wallet/EVMSigner";
+import {EVMTx} from "../chain/modules/EVMTransactions";
+import {EVMContractBase} from "../contract/EVMContractBase";
+import {EVMSigner} from "../wallet/EVMSigner";
 import {SpvVaultContractAbi} from "./SpvVaultContractAbi";
 import {SpvVaultManager, SpvVaultParametersStructOutput} from "./SpvVaultContractTypechain";
 import {EVMBtcRelay} from "../btcrelay/EVMBtcRelay";
@@ -204,7 +204,7 @@ export class EVMSpvVaultContract<ChainId extends string>
     }
 
     //Getters
-    async getFronterAddress(owner: string, vaultId: bigint, withdrawal: EVMSpvWithdrawalData): Promise<string> {
+    async getFronterAddress(owner: string, vaultId: bigint, withdrawal: EVMSpvWithdrawalData): Promise<string | null> {
         const frontingAddress = await this.contract.getFronterById(owner, vaultId, "0x"+withdrawal.getFrontingId());
         if(frontingAddress===ZeroAddress) return null;
         return frontingAddress;
@@ -370,58 +370,114 @@ export class EVMSpvVaultContract<ChainId extends string>
         }
     }
 
-    async getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState> {
-        const txHash = Buffer.from(btcTxId, "hex").reverse();
-        let result: SpvWithdrawalState = await this.Events.findInContractEvents(
-            ["Fronted", "Claimed", "Closed"],
-            [
-                null,
-                null,
-                hexlify(txHash)
-            ],
-            async (event) => {
-                const result = this.parseWithdrawalEvent(event);
-                if(result!=null) return result;
-            }
-        );
+    async getWithdrawalState(withdrawalTx: EVMSpvWithdrawalData, scStartHeight?: number): Promise<SpvWithdrawalState> {
+        const txHash = Buffer.from(withdrawalTx.getTxId(), "hex").reverse();
+
+        const events: ["Fronted", "Claimed", "Closed"] = ["Fronted", "Claimed", "Closed"];
+        const keys = [null, null, hexlify(txHash)];
+
+        let result: SpvWithdrawalState;
+        if(scStartHeight==null) {
+            result = await this.Events.findInContractEvents(
+                events, keys,
+                async (event) => {
+                    const result = this.parseWithdrawalEvent(event);
+                    if(result!=null) return result;
+                }
+            );
+        } else {
+            result = await this.Events.findInContractEventsForward(
+                events, keys,
+                async (event) => {
+                    const result = this.parseWithdrawalEvent(event);
+                    if(result==null) return;
+                    if(result.type===SpvWithdrawalStateType.FRONTED) {
+                        //Check if still fronted
+                        const fronterAddress = await this.getFronterAddress(result.owner, result.vaultId, withdrawalTx);
+                        //Not fronted now, there should be a claim/close event after the front event, continue
+                        if(fronterAddress==null) return;
+                    }
+                    return result;
+                },
+                scStartHeight
+            );
+        }
         result ??= {
             type: SpvWithdrawalStateType.NOT_FOUND
         };
         return result;
     }
 
-    async getWithdrawalStates(btcTxIds: string[]): Promise<{[btcTxId: string]: SpvWithdrawalState}> {
+    async getWithdrawalStates(withdrawalTxs: {withdrawal: EVMSpvWithdrawalData, scStartBlockheight?: number}[]): Promise<{[btcTxId: string]: SpvWithdrawalState}> {
         const result: {[btcTxId: string]: SpvWithdrawalState} = {};
 
-        for(let i=0;i<btcTxIds.length;i+=this.Chain.config.maxLogTopics) {
-            const checkBtcTxIds = btcTxIds.slice(i, i+this.Chain.config.maxLogTopics);
-            const checkBtcTxIdsSet = new Set(checkBtcTxIds);
+        const events: ["Fronted", "Claimed", "Closed"] = ["Fronted", "Claimed", "Closed"];
 
-            await this.Events.findInContractEvents(
-                ["Fronted", "Claimed", "Closed"],
-                [
-                    null,
-                    null,
-                    checkBtcTxIds.map(btcTxId => hexlify(Buffer.from(btcTxId, "hex").reverse()))
-                ],
-                async (event) => {
-                    const _event = event as TypedEventLog<SpvVaultManager["filters"]["Fronted" | "Claimed" | "Closed"]>;
-                    const btcTxId = Buffer.from(_event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
-                    if(!checkBtcTxIdsSet.has(btcTxId)) {
-                        this.logger.warn(`getWithdrawalStates(): findInContractEvents-callback: loaded event for ${btcTxId}, but transaction not found in input params!`)
-                        return null;
-                    }
-                    const eventResult = this.parseWithdrawalEvent(event);
-                    if(eventResult==null) return null;
-                    checkBtcTxIdsSet.delete(btcTxId);
-                    result[btcTxId] = eventResult;
-                    if(checkBtcTxIdsSet.size===0) return true; //All processed
+        for(let i=0;i<withdrawalTxs.length;i+=this.Chain.config.maxLogTopics) {
+            const checkWithdrawalTxs = withdrawalTxs.slice(i, i+this.Chain.config.maxLogTopics);
+            const checkWithdrawalTxsMap = new Map(checkWithdrawalTxs.map(val => [val.withdrawal.getTxId() as string, val.withdrawal]));
+
+            let scStartHeight = null;
+            for(let val of checkWithdrawalTxs) {
+                if(val.scStartBlockheight==null) {
+                    scStartHeight = null;
+                    break;
                 }
-            );
+                scStartHeight = Math.min(scStartHeight ?? Infinity, val.scStartBlockheight);
+            }
+
+            const keys = [null, null, checkWithdrawalTxs.map(withdrawal => hexlify(Buffer.from(withdrawal.withdrawal.getTxId(), "hex").reverse()))];
+
+            if(scStartHeight==null) {
+                await this.Events.findInContractEvents(
+                    events, keys,
+                    async (event) => {
+                        const _event = event as TypedEventLog<SpvVaultManager["filters"]["Fronted" | "Claimed" | "Closed"]>;
+                        const btcTxId = Buffer.from(_event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
+                        if(!checkWithdrawalTxsMap.has(btcTxId)) {
+                            this.logger.warn(`getWithdrawalStates(): findInContractEvents-callback: loaded event for ${btcTxId}, but transaction not found in input params!`)
+                            return null;
+                        }
+                        const eventResult = this.parseWithdrawalEvent(event);
+                        if(eventResult==null) return null;
+                        checkWithdrawalTxsMap.delete(btcTxId);
+                        result[btcTxId] = eventResult;
+                        if(checkWithdrawalTxsMap.size===0) return true; //All processed
+                    }
+                );
+            } else {
+                await this.Events.findInContractEventsForward(
+                    events, keys,
+                    async (event) => {
+                        const _event = event as TypedEventLog<SpvVaultManager["filters"]["Fronted" | "Claimed" | "Closed"]>;
+                        const btcTxId = Buffer.from(_event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
+                        const withdrawalTx = checkWithdrawalTxsMap.get(btcTxId);
+                        if(withdrawalTx==null) {
+                            this.logger.warn(`getWithdrawalStates(): findInContractEvents-callback: loaded event for ${btcTxId}, but transaction not found in input params!`)
+                            return;
+                        }
+                        const eventResult = this.parseWithdrawalEvent(event);
+                        if(eventResult==null) return;
+
+                        if(eventResult.type===SpvWithdrawalStateType.FRONTED) {
+                            //Check if still fronted
+                            const fronterAddress = await this.getFronterAddress(eventResult.owner, eventResult.vaultId, withdrawalTx);
+                            //Not fronted now, so there should be a claim/close event after the front event, continue
+                            if(fronterAddress==null) return;
+                            //Fronted still, so this should be the latest current state
+                        }
+
+                        checkWithdrawalTxsMap.delete(btcTxId);
+                        result[btcTxId] = eventResult;
+                        if(checkWithdrawalTxsMap.size===0) return true; //All processed
+                    },
+                    scStartHeight
+                );
+            }
         }
 
-        for(let btcTxId of btcTxIds) {
-            result[btcTxId] ??= {
+        for(let val of withdrawalTxs) {
+            result[val.withdrawal.getTxId()] ??= {
                 type: SpvWithdrawalStateType.NOT_FOUND
             };
         }

package/src/evm/wallet/EVMPersistentSigner.ts

@@ -130,12 +130,14 @@ export class EVMPersistentSigner extends EVMSigner {
 
         for(let [nonce, data] of this.pendingTxs) {
             if(!data.sending && data.lastBumped<Date.now()-this.waitBeforeBump) {
-                _safeBlockTxCount = await this.chainInterface.provider.getTransactionCount(this.address, this.safeBlockTag);
-                this.confirmedNonce = _safeBlockTxCount;
-                if(_safeBlockTxCount > nonce) {
+                if(_safeBlockTxCount==null) {
+                    _safeBlockTxCount = await this.chainInterface.provider.getTransactionCount(this.address, this.safeBlockTag);
+                    this.confirmedNonce = _safeBlockTxCount - 1;
+                }
+                if(this.confirmedNonce >= nonce) {
                     this.pendingTxs.delete(nonce);
                     data.txs.forEach(tx => this.chainInterface.Transactions._knownTxSet.delete(tx.hash));
-                    this.logger.info("checkPastTransactions(): Tx confirmed, required fee bumps: ", data.txs.length);
+                    this.logger.info(`checkPastTransactions(): Tx confirmed, nonce: ${nonce}, required fee bumps: `, data.txs.length);
                     this.save();
                     continue;
                 }
@@ -228,6 +230,23 @@ export class EVMPersistentSigner extends EVMSigner {
         func();
     }
 
+    private async syncNonceFromChain() {
+        const txCount = await this.chainInterface.provider.getTransactionCount(this.address, this.safeBlockTag);
+        this.confirmedNonce = txCount-1;
+        if(this.pendingNonce < this.confirmedNonce) {
+            this.logger.info(`syncNonceFromChain(): Re-synced latest nonce from chain, adjusting local pending nonce ${this.pendingNonce} -> ${this.confirmedNonce}`);
+            this.pendingNonce = this.confirmedNonce;
+            for(let [nonce, data] of this.pendingTxs) {
+                if(nonce <= this.pendingNonce) {
+                    this.pendingTxs.delete(nonce);
+                    data.txs.forEach(tx => this.chainInterface.Transactions._knownTxSet.delete(tx.hash));
+                    this.logger.info(`syncNonceFromChain(): Tx confirmed, nonce: ${nonce}, required fee bumps: `, data.txs.length);
+                }
+            }
+            this.save();
+        }
+    }
+
     async init(): Promise<void> {
         try {
             await fs.mkdir(this.directory)
@@ -291,10 +310,17 @@ export class EVMPersistentSigner extends EVMSigner {
             this.chainInterface.Transactions._knownTxSet.add(signedTx.hash);
 
             try {
+                //TODO: This can fail due to not receiving a response from the server, however the transaction
+                // might already be broadcasted!
                 const result = await this.chainInterface.provider.broadcastTransaction(signedRawTx);
                 pendingTxObject.sending = false;
                 return result;
             } catch (e) {
+                if(e.code==="NONCE_EXPIRED") {
+                    //Re-check nonce from on-chain
+                    this.logger.info("sendTransaction(): Got NONCE_EXPIRED back from backend, re-checking latest nonce from chain!");
+                    await this.syncNonceFromChain();
+                }
                 this.chainInterface.Transactions._knownTxSet.delete(signedTx.hash);
                 this.pendingTxs.delete(transaction.nonce);
                 this.pendingNonce--;