@atomiqlabs/chain-evm 1.0.0-dev.89 → 1.0.0-dev.92

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

@@ -1,6 +1,6 @@
 import { BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType } from "@atomiqlabs/base";
 import { JsonRpcApiProvider } from "ethers";
-import { EVMRetryPolicy } from "../../evm/chain/EVMChainInterface";
+import { EVMConfiguration, EVMRetryPolicy } from "../../evm/chain/EVMChainInterface";
 import { EVMFees } from "../../evm/chain/modules/EVMFees";
 import { BotanixChainType } from "./BotanixChainType";
 export type BotanixAssetsType = BaseTokenType<"BBTC">;
@@ -9,7 +9,6 @@ export type BotanixOptions = {
     rpcUrl: string | JsonRpcApiProvider;
     retryPolicy?: EVMRetryPolicy;
     chainType?: "MAINNET" | "TESTNET";
-    maxLogsBlockRange?: number;
     swapContract?: string;
     btcRelayContract?: string;
     btcRelayDeploymentHeight?: number;
@@ -24,6 +23,7 @@ export type BotanixOptions = {
         };
     };
     fees?: EVMFees;
+    evmConfig?: Omit<EVMConfiguration, "safeBlockTag">;
 };
 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,7 +84,11 @@ 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",
-        maxLogsBlockRange: options.maxLogsBlockRange ?? 500
+        maxLogsBlockRange: 950,
+        maxLogTopics: 64,
+        maxParallelLogRequests: 5,
+        maxParallelCalls: 5,
+        ...options?.evmConfig
     }, options.retryPolicy, Fees);
     const btcRelay = new EVMBtcRelay_1.EVMBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract ?? defaultContractAddresses.btcRelayContract, options.btcRelayDeploymentHeight ?? defaultContractAddresses.btcRelayDeploymentHeight);
     const swapContract = new EVMSwapContract_1.EVMSwapContract(chainInterface, btcRelay, options.swapContract ?? defaultContractAddresses.swapContract, {

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

@@ -1,6 +1,6 @@
 import { BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType } from "@atomiqlabs/base";
 import { JsonRpcApiProvider } from "ethers";
-import { EVMRetryPolicy } from "../../evm/chain/EVMChainInterface";
+import { EVMConfiguration, EVMRetryPolicy } from "../../evm/chain/EVMChainInterface";
 import { CitreaChainType } from "./CitreaChainType";
 import { CitreaFees } from "./CitreaFees";
 export type CitreaAssetsType = BaseTokenType<"CBTC" | "USDC">;
@@ -9,7 +9,6 @@ export type CitreaOptions = {
     rpcUrl: string | JsonRpcApiProvider;
     retryPolicy?: EVMRetryPolicy;
     chainType?: "MAINNET" | "TESTNET4";
-    maxLogsBlockRange?: number;
     swapContract?: string;
     btcRelayContract?: string;
     btcRelayDeploymentHeight?: number;
@@ -24,6 +23,7 @@ export type CitreaOptions = {
         };
     };
     fees?: CitreaFees;
+    evmConfig?: Omit<EVMConfiguration, "safeBlockTag">;
 };
 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,7 +90,11 @@ 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",
-        maxLogsBlockRange: options.maxLogsBlockRange ?? 500
+        maxLogsBlockRange: 950,
+        maxLogTopics: 64,
+        maxParallelLogRequests: 5,
+        maxParallelCalls: 5,
+        ...options?.evmConfig
     }, options.retryPolicy, Fees);
     chainInterface.Tokens = new CitreaTokens_1.CitreaTokens(chainInterface); //Override with custom token module allowing l1 state diff based fee calculation
     const btcRelay = new CitreaBtcRelay_1.CitreaBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract ?? defaultContractAddresses.btcRelayContract, options.btcRelayDeploymentHeight ?? defaultContractAddresses.btcRelayDeploymentHeight);

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

@@ -16,6 +16,9 @@ export type EVMRetryPolicy = {
 export type EVMConfiguration = {
     safeBlockTag: EVMBlockTag;
     maxLogsBlockRange: number;
+    maxParallelLogRequests: number;
+    maxParallelCalls: number;
+    maxLogTopics: number;
 };
 export declare class EVMChainInterface<ChainId extends string = string> implements ChainInterface {
     readonly chainId: ChainId;

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

@@ -91,19 +91,27 @@ class EVMEvents extends EVMModule_1.EVMModule {
      */
     async findInEvents(contract, topics, processor, abortSignal, genesisHeight) {
         const { number: latestBlockNumber } = await this.provider.getBlock(this.root.config.safeBlockTag);
+        let promises = [];
         for (let blockNumber = latestBlockNumber; blockNumber >= (genesisHeight ?? 0); blockNumber -= this.root.config.maxLogsBlockRange) {
-            const eventsResult = await this.provider.getLogs({
-                address: contract,
-                topics,
-                fromBlock: Math.max(blockNumber - this.root.config.maxLogsBlockRange, 0),
-                toBlock: blockNumber === latestBlockNumber ? this.root.config.safeBlockTag : blockNumber
-            });
-            if (abortSignal != null)
-                abortSignal.throwIfAborted();
-            const result = await processor(eventsResult.reverse()); //Newest events first
-            if (result != null)
-                return result;
+            promises.push(this.getLogs(contract, topics, Math.max(blockNumber - this.root.config.maxLogsBlockRange, 0), blockNumber));
+            if (promises.length >= this.root.config.maxParallelLogRequests) {
+                const eventsResult = (await Promise.all(promises)).map(arr => arr.reverse() //Oldest events first
+                ).flat();
+                promises = [];
+                if (abortSignal != null)
+                    abortSignal.throwIfAborted();
+                const result = await processor(eventsResult);
+                if (result != null)
+                    return result;
+            }
         }
+        const eventsResult = (await Promise.all(promises)).map(arr => arr.reverse() //Oldest events first
+        ).flat();
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
+        const result = await processor(eventsResult); //Oldest events first
+        if (result != null)
+            return result;
         return null;
     }
     /**
@@ -118,19 +126,25 @@ class EVMEvents extends EVMModule_1.EVMModule {
      */
     async findInEventsForward(contract, topics, processor, abortSignal, startHeight) {
         const { number: latestBlockNumber } = await this.provider.getBlock(this.root.config.safeBlockTag);
+        let promises = [];
         for (let blockNumber = startHeight ?? 0; blockNumber < latestBlockNumber; blockNumber += this.root.config.maxLogsBlockRange) {
-            const eventsResult = await this.provider.getLogs({
-                address: contract,
-                topics,
-                fromBlock: blockNumber,
-                toBlock: (blockNumber + this.root.config.maxLogsBlockRange) > latestBlockNumber ? this.root.config.safeBlockTag : blockNumber + this.root.config.maxLogsBlockRange
-            });
-            if (abortSignal != null)
-                abortSignal.throwIfAborted();
-            const result = await processor(eventsResult); //Oldest events first
-            if (result != null)
-                return result;
+            promises.push(this.getLogs(contract, topics, blockNumber, Math.min(blockNumber + this.root.config.maxLogsBlockRange, latestBlockNumber)));
+            if (promises.length >= this.root.config.maxParallelLogRequests) {
+                const eventsResult = (await Promise.all(promises)).flat();
+                promises = [];
+                if (abortSignal != null)
+                    abortSignal.throwIfAborted();
+                const result = await processor(eventsResult); //Oldest events first
+                if (result != null)
+                    return result;
+            }
         }
+        const eventsResult = (await Promise.all(promises)).flat();
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
+        const result = await processor(eventsResult); //Oldest events first
+        if (result != null)
+            return result;
         return null;
     }
 }

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

@@ -28,7 +28,7 @@ export declare class EVMContractEvents<T extends BaseContract> extends EVMEvents
      *  if the search should continue
      * @param abortSignal
      */
-    findInContractEvents<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: string[], processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>, abortSignal?: AbortSignal): Promise<TResult>;
+    findInContractEvents<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: (string | string[])[], processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>, abortSignal?: AbortSignal): Promise<TResult>;
     /**
      * Runs a search forwards in time, processing the events for a specific topic
      *
@@ -38,5 +38,5 @@ export declare class EVMContractEvents<T extends BaseContract> extends EVMEvents
      *  if the search should continue
      * @param abortSignal
      */
-    findInContractEventsForward<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: 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>, abortSignal?: AbortSignal): Promise<TResult>;
 }

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

@@ -41,10 +41,38 @@ export declare class EVMSpvVaultContract<ChainId extends string> extends EVMCont
     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>;
+    getFronterAddresses(withdrawals: {
+        owner: string;
+        vaultId: bigint;
+        withdrawal: EVMSpvWithdrawalData;
+    }[]): Promise<{
+        [btcTxId: string]: string | null;
+    }>;
     private vaultParamsCache;
     getVaultData(owner: string, vaultId: bigint): Promise<EVMSpvVaultData>;
+    getMultipleVaultData(vaults: {
+        owner: string;
+        vaultId: bigint;
+    }[]): Promise<{
+        [owner: string]: {
+            [vaultId: string]: EVMSpvVaultData;
+        };
+    }>;
+    getVaultLatestUtxo(owner: string, vaultId: bigint): Promise<string | null>;
+    getVaultLatestUtxos(vaults: {
+        owner: string;
+        vaultId: bigint;
+    }[]): Promise<{
+        [owner: string]: {
+            [vaultId: string]: string | null;
+        };
+    }>;
     getAllVaults(owner?: string): Promise<EVMSpvVaultData[]>;
+    private parseWithdrawalEvent;
     getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState>;
+    getWithdrawalStates(btcTxIds: string[]): Promise<{
+        [btcTxId: string]: SpvWithdrawalState;
+    }>;
     getWithdrawalData(btcTx: BtcTx): Promise<EVMSpvWithdrawalData>;
     fromOpReturnData(data: Buffer): {
         recipient: string;

package/dist/evm/spv_swap/EVMSpvVaultContract.js

@@ -125,6 +125,22 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             return null;
         return frontingAddress;
     }
+    async getFronterAddresses(withdrawals) {
+        const result = {};
+        let promises = [];
+        //TODO: We can upgrade this to use multicall
+        for (let { owner, vaultId, withdrawal } of withdrawals) {
+            promises.push(this.getFronterAddress(owner, vaultId, withdrawal).then(val => {
+                result[withdrawal.getTxId()] = val;
+            }));
+            if (promises.length >= this.Chain.config.maxParallelCalls) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return result;
+    }
     async getVaultData(owner, vaultId) {
         const vaultState = await this.contract.getVault(owner, vaultId);
         const vaultParams = await this.vaultParamsCache.getOrComputeAsync(vaultState.spvVaultParametersCommitment, async () => {
@@ -142,6 +158,47 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             return null;
         return new EVMSpvVaultData_1.EVMSpvVaultData(owner, vaultId, vaultState, vaultParams);
     }
+    async getMultipleVaultData(vaults) {
+        const result = {};
+        let promises = [];
+        //TODO: We can upgrade this to use multicall
+        for (let { owner, vaultId } of vaults) {
+            promises.push(this.getVaultData(owner, vaultId).then(val => {
+                result[owner] ?? (result[owner] = {});
+                result[owner][vaultId.toString(10)] = val;
+            }));
+            if (promises.length >= this.Chain.config.maxParallelCalls) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return result;
+    }
+    async getVaultLatestUtxo(owner, vaultId) {
+        const vaultState = await this.contract.getVault(owner, vaultId);
+        const utxo = (0, EVMSpvVaultData_1.getVaultUtxoFromState)(vaultState);
+        if (utxo === "0000000000000000000000000000000000000000000000000000000000000000:0")
+            return null;
+        return utxo;
+    }
+    async getVaultLatestUtxos(vaults) {
+        const result = {};
+        let promises = [];
+        //TODO: We can upgrade this to use multicall
+        for (let { owner, vaultId } of vaults) {
+            promises.push(this.getVaultLatestUtxo(owner, vaultId).then(val => {
+                result[owner] ?? (result[owner] = {});
+                result[owner][vaultId.toString(10)] = val;
+            }));
+            if (promises.length >= this.Chain.config.maxParallelCalls) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return result;
+    }
     async getAllVaults(owner) {
         const openedVaults = new Map();
         await this.Events.findInContractEventsForward(["Opened", "Closed"], owner == null ? null : [
@@ -167,6 +224,44 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         }
         return vaults;
     }
+    parseWithdrawalEvent(event) {
+        switch (event.eventName) {
+            case "Fronted":
+                const frontedEvent = event;
+                const [ownerFront, vaultIdFront] = unpackOwnerAndVaultId(frontedEvent.args.ownerAndVaultId);
+                return {
+                    type: base_1.SpvWithdrawalStateType.FRONTED,
+                    txId: event.transactionHash,
+                    owner: ownerFront,
+                    vaultId: vaultIdFront,
+                    recipient: frontedEvent.args.recipient,
+                    fronter: frontedEvent.args.caller
+                };
+            case "Claimed":
+                const claimedEvent = event;
+                const [ownerClaim, vaultIdClaim] = unpackOwnerAndVaultId(claimedEvent.args.ownerAndVaultId);
+                return {
+                    type: base_1.SpvWithdrawalStateType.CLAIMED,
+                    txId: event.transactionHash,
+                    owner: ownerClaim,
+                    vaultId: vaultIdClaim,
+                    recipient: claimedEvent.args.recipient,
+                    claimer: claimedEvent.args.caller,
+                    fronter: claimedEvent.args.frontingAddress
+                };
+            case "Closed":
+                const closedEvent = event;
+                return {
+                    type: base_1.SpvWithdrawalStateType.CLOSED,
+                    txId: event.transactionHash,
+                    owner: closedEvent.args.owner,
+                    vaultId: closedEvent.args.vaultId,
+                    error: closedEvent.args.error
+                };
+            default:
+                return null;
+        }
+    }
     async getWithdrawalState(btcTxId) {
         const txHash = buffer_1.Buffer.from(btcTxId, "hex").reverse();
         let result = await this.Events.findInContractEvents(["Fronted", "Claimed", "Closed"], [
@@ -174,46 +269,47 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             null,
             (0, ethers_1.hexlify)(txHash)
         ], async (event) => {
-            switch (event.eventName) {
-                case "Fronted":
-                    const frontedEvent = event;
-                    const [ownerFront, vaultIdFront] = unpackOwnerAndVaultId(frontedEvent.args.ownerAndVaultId);
-                    return {
-                        type: base_1.SpvWithdrawalStateType.FRONTED,
-                        txId: event.transactionHash,
-                        owner: ownerFront,
-                        vaultId: vaultIdFront,
-                        recipient: frontedEvent.args.recipient,
-                        fronter: frontedEvent.args.caller
-                    };
-                case "Claimed":
-                    const claimedEvent = event;
-                    const [ownerClaim, vaultIdClaim] = unpackOwnerAndVaultId(claimedEvent.args.ownerAndVaultId);
-                    return {
-                        type: base_1.SpvWithdrawalStateType.CLAIMED,
-                        txId: event.transactionHash,
-                        owner: ownerClaim,
-                        vaultId: vaultIdClaim,
-                        recipient: claimedEvent.args.recipient,
-                        claimer: claimedEvent.args.caller,
-                        fronter: claimedEvent.args.frontingAddress
-                    };
-                case "Closed":
-                    const closedEvent = event;
-                    return {
-                        type: base_1.SpvWithdrawalStateType.CLOSED,
-                        txId: event.transactionHash,
-                        owner: closedEvent.args.owner,
-                        vaultId: closedEvent.args.vaultId,
-                        error: closedEvent.args.error
-                    };
-            }
+            const result = this.parseWithdrawalEvent(event);
+            if (result != null)
+                return result;
         });
         result ?? (result = {
             type: base_1.SpvWithdrawalStateType.NOT_FOUND
         });
         return result;
     }
+    async getWithdrawalStates(btcTxIds) {
+        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 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 btcTxId of btcTxIds) {
+            result[btcTxId] ?? (result[btcTxId] = {
+                type: base_1.SpvWithdrawalStateType.NOT_FOUND
+            });
+        }
+        return result;
+    }
     getWithdrawalData(btcTx) {
         return Promise.resolve(new EVMSpvWithdrawalData_1.EVMSpvWithdrawalData(btcTx));
     }

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

@@ -2,6 +2,7 @@ import { SpvVaultClaimEvent, SpvVaultCloseEvent, SpvVaultData, SpvVaultDepositEv
 import { EVMSpvWithdrawalData } from "./EVMSpvWithdrawalData";
 import { SpvVaultParametersStruct, SpvVaultStateStruct } from "./SpvVaultContractTypechain";
 export declare function getVaultParamsCommitment(vaultParams: SpvVaultParametersStruct): string;
+export declare function getVaultUtxoFromState(state: SpvVaultStateStruct): string;
 export declare class EVMSpvVaultData extends SpvVaultData<EVMSpvWithdrawalData> {
     readonly owner: string;
     readonly vaultId: bigint;

package/dist/evm/spv_swap/EVMSpvVaultData.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMSpvVaultData = exports.getVaultParamsCommitment = void 0;
+exports.EVMSpvVaultData = exports.getVaultUtxoFromState = exports.getVaultParamsCommitment = void 0;
 const base_1 = require("@atomiqlabs/base");
 const buffer_1 = require("buffer");
 const EVMSpvWithdrawalData_1 = require("./EVMSpvWithdrawalData");
@@ -11,6 +11,11 @@ function getVaultParamsCommitment(vaultParams) {
     return (0, ethers_2.keccak256)(ethers_2.AbiCoder.defaultAbiCoder().encode(["address", "address", "address", "uint192", "uint192", "uint256"], [vaultParams.btcRelayContract, vaultParams.token0, vaultParams.token1, vaultParams.token0Multiplier, vaultParams.token1Multiplier, vaultParams.confirmations]));
 }
 exports.getVaultParamsCommitment = getVaultParamsCommitment;
+function getVaultUtxoFromState(state) {
+    const txHash = buffer_1.Buffer.from((0, ethers_1.hexlify)(state.utxoTxHash).substring(2), "hex");
+    return txHash.reverse().toString("hex") + ":" + BigInt(state.utxoVout).toString(10);
+}
+exports.getVaultUtxoFromState = getVaultUtxoFromState;
 class EVMSpvVaultData extends base_1.SpvVaultData {
     constructor(ownerOrObj, vaultId, state, params, initialUtxo) {
         super();
@@ -28,8 +33,7 @@ class EVMSpvVaultData extends base_1.SpvVaultData {
                 multiplier: BigInt(params.token1Multiplier),
                 rawAmount: BigInt(state.token1Amount)
             };
-            const txHash = buffer_1.Buffer.from((0, ethers_1.hexlify)(state.utxoTxHash).substring(2), "hex");
-            this.utxo = txHash.reverse().toString("hex") + ":" + BigInt(state.utxoVout).toString(10);
+            this.utxo = getVaultUtxoFromState(state);
             this.confirmations = Number(params.confirmations);
             this.withdrawCount = Number(state.withdrawCount);
             this.depositCount = Number(state.depositCount);

package/dist/evm/swaps/EVMSwapContract.d.ts

@@ -128,6 +128,12 @@ export declare class EVMSwapContract<ChainId extends string = string> extends EV
      * @param data
      */
     getCommitStatus(signer: string, data: EVMSwapData): Promise<SwapCommitState>;
+    getCommitStatuses(request: {
+        signer: string;
+        swapData: EVMSwapData;
+    }[]): Promise<{
+        [p: string]: SwapCommitState;
+    }>;
     /**
      * Returns the data committed for a specific payment hash, or null if no data is currently commited for
      *  the specific swap

package/dist/evm/swaps/EVMSwapContract.js

@@ -243,6 +243,22 @@ class EVMSwapContract extends EVMContractBase_1.EVMContractBase {
                 };
         }
     }
+    async getCommitStatuses(request) {
+        const result = {};
+        let promises = [];
+        //TODO: We can upgrade this to use multicall
+        for (let { signer, swapData } of request) {
+            promises.push(this.getCommitStatus(signer, swapData).then(val => {
+                result[swapData.getEscrowHash()] = val;
+            }));
+            if (promises.length >= this.Chain.config.maxParallelCalls) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return result;
+    }
     /**
      * Returns the data committed for a specific payment hash, or null if no data is currently commited for
      *  the specific swap

package/dist/utils/Utils.js

@@ -83,7 +83,7 @@ exports.allowedEthersErrorNumbers = new Set([
     -32700,
     -32600,
     -32601,
-    // -32602, //Invalid params
+    -32602,
     // -32603, //Internal error
     -32000,
     // -32001, //Resource not found

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-evm",
-  "version": "1.0.0-dev.89",
+  "version": "1.0.0-dev.92",
   "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.10",
+    "@atomiqlabs/base": "^10.0.0-dev.13",
     "@noble/hashes": "^1.8.0",
     "@scure/btc-signer": "^1.6.0",
     "buffer": "6.0.3",

package/src/chains/botanix/BotanixInitializer.ts

@@ -1,6 +1,6 @@
 import {BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType} from "@atomiqlabs/base";
 import {JsonRpcApiProvider, JsonRpcProvider, WebSocketProvider} from "ethers";
-import {EVMChainInterface, EVMRetryPolicy} from "../../evm/chain/EVMChainInterface";
+import {EVMChainInterface, EVMConfiguration, EVMRetryPolicy} from "../../evm/chain/EVMChainInterface";
 import {EVMFees} from "../../evm/chain/modules/EVMFees";
 import {EVMBtcRelay} from "../../evm/btcrelay/EVMBtcRelay";
 import {EVMSwapContract} from "../../evm/swaps/EVMSwapContract";
@@ -70,7 +70,6 @@ export type BotanixOptions = {
     rpcUrl: string | JsonRpcApiProvider,
     retryPolicy?: EVMRetryPolicy,
     chainType?: "MAINNET" | "TESTNET",
-    maxLogsBlockRange?: number,
 
     swapContract?: string,
     btcRelayContract?: string,
@@ -86,7 +85,9 @@ export type BotanixOptions = {
         }
     }
 
-    fees?: EVMFees
+    fees?: EVMFees,
+
+    evmConfig?: Omit<EVMConfiguration, "safeBlockTag">
 }
 
 export function initializeBotanix(
@@ -120,7 +121,11 @@ export function initializeBotanix(
 
     const chainInterface = new EVMChainInterface("BOTANIX", chainId, provider, {
         safeBlockTag: "finalized",
-        maxLogsBlockRange: options.maxLogsBlockRange ?? 500
+        maxLogsBlockRange: 950,
+        maxLogTopics: 64,
+        maxParallelLogRequests: 5,
+        maxParallelCalls: 5,
+        ...options?.evmConfig
     }, options.retryPolicy, Fees);
 
     const btcRelay = new EVMBtcRelay(

package/src/chains/citrea/CitreaInitializer.ts

@@ -1,6 +1,6 @@
 import {BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType} from "@atomiqlabs/base";
 import {JsonRpcApiProvider, JsonRpcProvider, WebSocketProvider} from "ethers";
-import {EVMChainInterface, EVMRetryPolicy} from "../../evm/chain/EVMChainInterface";
+import {EVMChainInterface, EVMConfiguration, EVMRetryPolicy} from "../../evm/chain/EVMChainInterface";
 import {CitreaChainType} from "./CitreaChainType";
 import {EVMChainEventsBrowser} from "../../evm/events/EVMChainEventsBrowser";
 import {EVMSwapData} from "../../evm/swaps/EVMSwapData";
@@ -76,7 +76,6 @@ export type CitreaOptions = {
     rpcUrl: string | JsonRpcApiProvider,
     retryPolicy?: EVMRetryPolicy,
     chainType?: "MAINNET" | "TESTNET4",
-    maxLogsBlockRange?: number,
 
     swapContract?: string,
     btcRelayContract?: string,
@@ -92,7 +91,9 @@ export type CitreaOptions = {
         }
     }
 
-    fees?: CitreaFees
+    fees?: CitreaFees,
+
+    evmConfig?: Omit<EVMConfiguration, "safeBlockTag">
 }
 
 export function initializeCitrea(
@@ -126,7 +127,11 @@ export function initializeCitrea(
 
     const chainInterface = new EVMChainInterface("CITREA", chainId, provider, {
         safeBlockTag: "latest",
-        maxLogsBlockRange: options.maxLogsBlockRange ?? 500
+        maxLogsBlockRange: 950,
+        maxLogTopics: 64,
+        maxParallelLogRequests: 5,
+        maxParallelCalls: 5,
+        ...options?.evmConfig
     }, options.retryPolicy, Fees);
     chainInterface.Tokens = new CitreaTokens(chainInterface); //Override with custom token module allowing l1 state diff based fee calculation
 

package/src/evm/chain/EVMChainInterface.ts

@@ -18,7 +18,10 @@ export type EVMRetryPolicy = {
 
 export type EVMConfiguration = {
     safeBlockTag: EVMBlockTag,
-    maxLogsBlockRange: number
+    maxLogsBlockRange: number,
+    maxParallelLogRequests: number,
+    maxParallelCalls: number,
+    maxLogTopics: number
 };
 
 export class EVMChainInterface<ChainId extends string = string> implements ChainInterface {

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

@@ -102,19 +102,35 @@ export class EVMEvents extends EVMModule<any> {
     ): Promise<T> {
         const {number: latestBlockNumber} = await this.provider.getBlock(this.root.config.safeBlockTag);
 
+        let promises: Promise<Log[]>[] = [];
         for(let blockNumber = latestBlockNumber; blockNumber >= (genesisHeight ?? 0); blockNumber-=this.root.config.maxLogsBlockRange) {
-            const eventsResult = await this.provider.getLogs({
-                address: contract,
+            promises.push(this.getLogs(
+                contract,
                 topics,
-                fromBlock: Math.max(blockNumber-this.root.config.maxLogsBlockRange, 0),
-                toBlock: blockNumber===latestBlockNumber ? this.root.config.safeBlockTag : blockNumber
-            });
+                Math.max(blockNumber-this.root.config.maxLogsBlockRange, 0),
+                blockNumber
+            ));
 
-            if(abortSignal!=null) abortSignal.throwIfAborted();
+            if(promises.length>=this.root.config.maxParallelLogRequests) {
+                const eventsResult = (await Promise.all(promises)).map(
+                    arr => arr.reverse() //Oldest events first
+                ).flat();
+                promises = [];
+                if(abortSignal!=null) abortSignal.throwIfAborted();
 
-            const result: T = await processor(eventsResult.reverse()); //Newest events first
-            if(result!=null) return result;
+                const result: T = await processor(eventsResult);
+                if(result!=null) return result;
+            }
         }
+
+        const eventsResult = (await Promise.all(promises)).map(
+            arr => arr.reverse() //Oldest events first
+        ).flat();
+        if(abortSignal!=null) abortSignal.throwIfAborted();
+
+        const result: T = await processor(eventsResult); //Oldest events first
+        if(result!=null) return result;
+
         return null;
     }
 
@@ -136,20 +152,30 @@ export class EVMEvents extends EVMModule<any> {
     ): Promise<T> {
         const {number: latestBlockNumber} = await this.provider.getBlock(this.root.config.safeBlockTag);
 
+        let promises: Promise<Log[]>[] = [];
         for(let blockNumber = startHeight ?? 0; blockNumber < latestBlockNumber; blockNumber += this.root.config.maxLogsBlockRange) {
-            const eventsResult = await this.provider.getLogs({
-                address: contract,
+            promises.push(this.getLogs(
+                contract,
                 topics,
-                fromBlock: blockNumber,
-                toBlock: (blockNumber + this.root.config.maxLogsBlockRange) > latestBlockNumber ? this.root.config.safeBlockTag : blockNumber + this.root.config.maxLogsBlockRange
-            });
-
-            if(abortSignal!=null) abortSignal.throwIfAborted();
+                blockNumber,
+                Math.min(blockNumber + this.root.config.maxLogsBlockRange, latestBlockNumber)
+            ));
+            if(promises.length>=this.root.config.maxParallelLogRequests) {
+                const eventsResult = (await Promise.all(promises)).flat();
+                promises = [];
+                if(abortSignal!=null) abortSignal.throwIfAborted();
 
-            const result: T = await processor(eventsResult); //Oldest events first
-            if(result!=null) return result;
+                const result: T = await processor(eventsResult); //Oldest events first
+                if(result!=null) return result;
+            }
         }
 
+        const eventsResult = (await Promise.all(promises)).flat();
+        if(abortSignal!=null) abortSignal.throwIfAborted();
+
+        const result: T = await processor(eventsResult); //Oldest events first
+        if(result!=null) return result;
+
         return null;
     }
 

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

@@ -21,7 +21,7 @@ export class EVMContractEvents<T extends BaseContract> extends EVMEvents {
 
     private toFilter<TEventName extends keyof T["filters"]>(
         events: TEventName[],
-        keys: string[],
+        keys: (string | string[])[],
     ): (string | string[])[] {
         const filterArray: (string | string[])[] = [];
         filterArray.push(events.map(name => {
@@ -61,7 +61,7 @@ export class EVMContractEvents<T extends BaseContract> extends EVMEvents {
      */
     public async findInContractEvents<TResult, TEventName extends keyof T["filters"]>(
         events: TEventName[],
-        keys: string[],
+        keys: (string | string[])[],
         processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>,
         abortSignal?: AbortSignal
     ): Promise<TResult> {
@@ -85,7 +85,7 @@ export class EVMContractEvents<T extends BaseContract> extends EVMEvents {
      */
     public async findInContractEventsForward<TResult, TEventName extends keyof T["filters"]>(
         events: TEventName[],
-        keys: string[],
+        keys: (string | string[])[],
         processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>,
         abortSignal?: AbortSignal
     ): Promise<TResult> {

package/src/evm/spv_swap/EVMSpvVaultContract.ts

@@ -21,7 +21,7 @@ import {getLogger} from "../../utils/Utils";
 import {EVMChainInterface} from "../chain/EVMChainInterface";
 import {AbiCoder, getAddress, hexlify, keccak256, TransactionRequest, ZeroAddress, ZeroHash} from "ethers";
 import {EVMAddresses} from "../chain/modules/EVMAddresses";
-import {EVMSpvVaultData, getVaultParamsCommitment} from "./EVMSpvVaultData";
+import {EVMSpvVaultData, getVaultParamsCommitment, getVaultUtxoFromState} from "./EVMSpvVaultData";
 import {EVMSpvWithdrawalData} from "./EVMSpvWithdrawalData";
 import {EVMFees} from "../chain/modules/EVMFees";
 import {EVMBtcStoredHeader} from "../btcrelay/headers/EVMBtcStoredHeader";
@@ -210,6 +210,25 @@ export class EVMSpvVaultContract<ChainId extends string>
         return frontingAddress;
     }
 
+    async getFronterAddresses(withdrawals: {owner: string, vaultId: bigint, withdrawal: EVMSpvWithdrawalData}[]): Promise<{[btcTxId: string]: string | null}> {
+        const result: {
+            [btcTxId: string]: string | null
+        } = {};
+        let promises: Promise<void>[] = [];
+        //TODO: We can upgrade this to use multicall
+        for(let {owner, vaultId, withdrawal} of withdrawals) {
+            promises.push(this.getFronterAddress(owner, vaultId, withdrawal).then(val => {
+                result[withdrawal.getTxId()] = val;
+            }));
+            if(promises.length>=this.Chain.config.maxParallelCalls) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return result;
+    }
+
     private vaultParamsCache: PromiseLruCache<string, SpvVaultParametersStructOutput> = new PromiseLruCache<string, SpvVaultParametersStructOutput>(5000);
 
     async getVaultData(owner: string, vaultId: bigint): Promise<EVMSpvVaultData> {
@@ -239,6 +258,49 @@ export class EVMSpvVaultContract<ChainId extends string>
         return new EVMSpvVaultData(owner, vaultId, vaultState, vaultParams);
     }
 
+    async getMultipleVaultData(vaults: {owner: string, vaultId: bigint}[]): Promise<{[owner: string]: {[vaultId: string]: EVMSpvVaultData}}> {
+        const result: {[owner: string]: {[vaultId: string]: EVMSpvVaultData}} = {};
+        let promises: Promise<void>[] = [];
+        //TODO: We can upgrade this to use multicall
+        for(let {owner, vaultId} of vaults) {
+            promises.push(this.getVaultData(owner, vaultId).then(val => {
+                result[owner] ??= {};
+                result[owner][vaultId.toString(10)] = val;
+            }));
+            if(promises.length>=this.Chain.config.maxParallelCalls) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return result;
+    }
+
+    async getVaultLatestUtxo(owner: string, vaultId: bigint): Promise<string | null> {
+        const vaultState = await this.contract.getVault(owner, vaultId);
+        const utxo = getVaultUtxoFromState(vaultState);
+        if(utxo==="0000000000000000000000000000000000000000000000000000000000000000:0") return null;
+        return utxo;
+    }
+
+    async getVaultLatestUtxos(vaults: {owner: string, vaultId: bigint}[]): Promise<{[owner: string]: {[vaultId: string]: string | null}}> {
+        const result: {[owner: string]: {[vaultId: string]: string | null}} = {};
+        let promises: Promise<void>[] = [];
+        //TODO: We can upgrade this to use multicall
+        for(let {owner, vaultId} of vaults) {
+            promises.push(this.getVaultLatestUtxo(owner, vaultId).then(val => {
+                result[owner] ??= {};
+                result[owner][vaultId.toString(10)] = val;
+            }));
+            if(promises.length>=this.Chain.config.maxParallelCalls) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return result;
+    }
+
     async getAllVaults(owner?: string): Promise<EVMSpvVaultData[]> {
         const openedVaults = new Map<string, SpvVaultParametersStructOutput>();
         await this.Events.findInContractEventsForward(
@@ -269,6 +331,45 @@ export class EVMSpvVaultContract<ChainId extends string>
         return vaults;
     }
 
+    private parseWithdrawalEvent(event: TypedEventLog<SpvVaultManager["filters"][keyof SpvVaultManager["filters"]]>): SpvWithdrawalState | null {
+        switch(event.eventName) {
+            case "Fronted":
+                const frontedEvent = event as TypedEventLog<SpvVaultManager["filters"]["Fronted"]>;
+                const [ownerFront, vaultIdFront] = unpackOwnerAndVaultId(frontedEvent.args.ownerAndVaultId);
+                return {
+                    type: SpvWithdrawalStateType.FRONTED,
+                    txId: event.transactionHash,
+                    owner: ownerFront,
+                    vaultId: vaultIdFront,
+                    recipient: frontedEvent.args.recipient,
+                    fronter: frontedEvent.args.caller
+                };
+            case "Claimed":
+                const claimedEvent = event as TypedEventLog<SpvVaultManager["filters"]["Claimed"]>;
+                const [ownerClaim, vaultIdClaim] = unpackOwnerAndVaultId(claimedEvent.args.ownerAndVaultId);
+                return {
+                    type: SpvWithdrawalStateType.CLAIMED,
+                    txId: event.transactionHash,
+                    owner: ownerClaim,
+                    vaultId: vaultIdClaim,
+                    recipient: claimedEvent.args.recipient,
+                    claimer: claimedEvent.args.caller,
+                    fronter: claimedEvent.args.frontingAddress
+                };
+            case "Closed":
+                const closedEvent = event as TypedEventLog<SpvVaultManager["filters"]["Closed"]>;
+                return {
+                    type: SpvWithdrawalStateType.CLOSED,
+                    txId: event.transactionHash,
+                    owner: closedEvent.args.owner,
+                    vaultId: closedEvent.args.vaultId,
+                    error: closedEvent.args.error
+                };
+            default:
+                return null;
+        }
+    }
+
     async getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState> {
         const txHash = Buffer.from(btcTxId, "hex").reverse();
         let result: SpvWithdrawalState = await this.Events.findInContractEvents(
@@ -279,40 +380,8 @@ export class EVMSpvVaultContract<ChainId extends string>
                 hexlify(txHash)
             ],
             async (event) => {
-                switch(event.eventName) {
-                    case "Fronted":
-                        const frontedEvent = event as TypedEventLog<SpvVaultManager["filters"]["Fronted"]>;
-                        const [ownerFront, vaultIdFront] = unpackOwnerAndVaultId(frontedEvent.args.ownerAndVaultId);
-                        return {
-                            type: SpvWithdrawalStateType.FRONTED,
-                            txId: event.transactionHash,
-                            owner: ownerFront,
-                            vaultId: vaultIdFront,
-                            recipient: frontedEvent.args.recipient,
-                            fronter: frontedEvent.args.caller
-                        };
-                    case "Claimed":
-                        const claimedEvent = event as TypedEventLog<SpvVaultManager["filters"]["Claimed"]>;
-                        const [ownerClaim, vaultIdClaim] = unpackOwnerAndVaultId(claimedEvent.args.ownerAndVaultId);
-                        return {
-                            type: SpvWithdrawalStateType.CLAIMED,
-                            txId: event.transactionHash,
-                            owner: ownerClaim,
-                            vaultId: vaultIdClaim,
-                            recipient: claimedEvent.args.recipient,
-                            claimer: claimedEvent.args.caller,
-                            fronter: claimedEvent.args.frontingAddress
-                        };
-                    case "Closed":
-                        const closedEvent = event as TypedEventLog<SpvVaultManager["filters"]["Closed"]>;
-                        return {
-                            type: SpvWithdrawalStateType.CLOSED,
-                            txId: event.transactionHash,
-                            owner: closedEvent.args.owner,
-                            vaultId: closedEvent.args.vaultId,
-                            error: closedEvent.args.error
-                        };
-                }
+                const result = this.parseWithdrawalEvent(event);
+                if(result!=null) return result;
             }
         );
         result ??= {
@@ -321,6 +390,45 @@ export class EVMSpvVaultContract<ChainId extends string>
         return result;
     }
 
+    async getWithdrawalStates(btcTxIds: string[]): 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);
+
+            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 btcTxId of btcTxIds) {
+            result[btcTxId] ??= {
+                type: SpvWithdrawalStateType.NOT_FOUND
+            };
+        }
+
+        return result;
+    }
+
     getWithdrawalData(btcTx: BtcTx): Promise<EVMSpvWithdrawalData> {
         return Promise.resolve(new EVMSpvWithdrawalData(btcTx));
     }

package/src/evm/spv_swap/EVMSpvVaultData.ts

@@ -23,6 +23,11 @@ export function getVaultParamsCommitment(vaultParams: SpvVaultParametersStruct)
     ));
 }
 
+export function getVaultUtxoFromState(state: SpvVaultStateStruct): string {
+    const txHash = Buffer.from(hexlify(state.utxoTxHash).substring(2), "hex");
+    return txHash.reverse().toString("hex")+":"+BigInt(state.utxoVout).toString(10);
+}
+
 export class EVMSpvVaultData extends SpvVaultData<EVMSpvWithdrawalData> {
 
     readonly owner: string;
@@ -63,8 +68,7 @@ export class EVMSpvVaultData extends SpvVaultData<EVMSpvWithdrawalData> {
                 multiplier: BigInt(params.token1Multiplier),
                 rawAmount: BigInt(state.token1Amount)
             };
-            const txHash = Buffer.from(hexlify(state.utxoTxHash).substring(2), "hex");
-            this.utxo = txHash.reverse().toString("hex")+":"+BigInt(state.utxoVout).toString(10);
+            this.utxo = getVaultUtxoFromState(state);
             this.confirmations = Number(params.confirmations);
             this.withdrawCount = Number(state.withdrawCount);
             this.depositCount = Number(state.depositCount);

package/src/evm/swaps/EVMSwapContract.ts

@@ -324,6 +324,27 @@ export class EVMSwapContract<ChainId extends string = string>
         }
     }
 
+    async getCommitStatuses(request: { signer: string; swapData: EVMSwapData }[]): Promise<{
+        [p: string]: SwapCommitState
+    }> {
+        const result: {
+            [p: string]: SwapCommitState
+        } = {};
+        let promises: Promise<void>[] = [];
+        //TODO: We can upgrade this to use multicall
+        for(let {signer, swapData} of request) {
+            promises.push(this.getCommitStatus(signer, swapData).then(val => {
+                result[swapData.getEscrowHash()] = val;
+            }));
+            if(promises.length>=this.Chain.config.maxParallelCalls) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return result;
+    }
+
     /**
      * Returns the data committed for a specific payment hash, or null if no data is currently commited for
      *  the specific swap

package/src/utils/Utils.ts

@@ -95,7 +95,7 @@ export const allowedEthersErrorNumbers: Set<number> = new Set([
     -32700, //Invalid JSON
     -32600, //Invalid request
     -32601, //Method not found
-    // -32602, //Invalid params
+    -32602, //Invalid params
     // -32603, //Internal error
     -32000, //Invalid input
     // -32001, //Resource not found