@atomiqlabs/chain-starknet 4.0.0-dev.20 → 4.0.0-dev.22

package/dist/starknet/StarknetInitializer.d.ts

@@ -1,6 +1,6 @@
 import { constants, Provider } from "starknet";
 import { StarknetFees } from "./chain/modules/StarknetFees";
-import { StarknetRetryPolicy } from "./chain/StarknetChainInterface";
+import { StarknetConfig, StarknetRetryPolicy } from "./chain/StarknetChainInterface";
 import { BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType } from "@atomiqlabs/base";
 import { StarknetChainType } from "./StarknetChainType";
 export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK" | "WBTC">;
@@ -21,6 +21,7 @@ export type StarknetOptions = {
         };
     };
     fees?: StarknetFees;
+    starknetConfig?: StarknetConfig;
 };
 export declare function initializeStarknet(options: StarknetOptions, bitcoinRpc: BitcoinRpc<any>, network: BitcoinNetwork): ChainData<StarknetChainType>;
 export type StarknetInitializerType = ChainInitializer<StarknetOptions, StarknetChainType, StarknetAssetsType>;

package/dist/starknet/StarknetInitializer.js

@@ -41,7 +41,7 @@ function initializeStarknet(options, bitcoinRpc, network) {
     const Fees = options.fees ?? new StarknetFees_1.StarknetFees(provider);
     const chainId = options.chainId ??
         (network === base_1.BitcoinNetwork.MAINNET ? starknet_1.constants.StarknetChainId.SN_MAIN : starknet_1.constants.StarknetChainId.SN_SEPOLIA);
-    const chainInterface = new StarknetChainInterface_1.StarknetChainInterface(chainId, provider, options.retryPolicy, Fees);
+    const chainInterface = new StarknetChainInterface_1.StarknetChainInterface(chainId, provider, options.retryPolicy, Fees, options.starknetConfig);
     const btcRelay = new StarknetBtcRelay_1.StarknetBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract);
     const swapContract = new StarknetSwapContract_1.StarknetSwapContract(chainInterface, btcRelay, options.swapContract, options.handlerContracts);
     const spvVaultContract = new StarknetSpvVaultContract_1.StarknetSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract);

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

@@ -13,6 +13,12 @@ export type StarknetRetryPolicy = {
     delay?: number;
     exponential?: boolean;
 };
+export type StarknetConfig = {
+    getLogChunkSize?: number;
+    getLogForwardBlockRange?: number;
+    maxGetLogKeys?: number;
+    maxParallelCalls?: number;
+};
 export declare class StarknetChainInterface implements ChainInterface {
     readonly chainId = "STARKNET";
     readonly provider: Provider;
@@ -31,7 +37,8 @@ export declare class StarknetChainInterface implements ChainInterface {
         warn: (msg: any, ...args: any[]) => void;
         error: (msg: any, ...args: any[]) => void;
     };
-    constructor(chainId: constants.StarknetChainId, provider: Provider, retryPolicy?: StarknetRetryPolicy, solanaFeeEstimator?: StarknetFees);
+    readonly config: StarknetConfig;
+    constructor(chainId: constants.StarknetChainId, provider: Provider, retryPolicy?: StarknetRetryPolicy, feeEstimator?: StarknetFees, options?: StarknetConfig);
     getBalance(signer: string, tokenAddress: string): Promise<bigint>;
     getNativeCurrencyAddress(): string;
     isValidToken(tokenIdentifier: string): boolean;

package/dist/starknet/chain/StarknetChainInterface.js

@@ -15,13 +15,19 @@ const StarknetSigner_1 = require("../wallet/StarknetSigner");
 const buffer_1 = require("buffer");
 const StarknetKeypairWallet_1 = require("../wallet/StarknetKeypairWallet");
 class StarknetChainInterface {
-    constructor(chainId, provider, retryPolicy, solanaFeeEstimator = new StarknetFees_1.StarknetFees(provider)) {
+    constructor(chainId, provider, retryPolicy, feeEstimator = new StarknetFees_1.StarknetFees(provider), options) {
+        var _a, _b, _c, _d;
         this.chainId = "STARKNET";
         this.logger = (0, Utils_1.getLogger)("StarknetChainInterface: ");
         this.starknetChainId = chainId;
         this.provider = provider;
         this.retryPolicy = retryPolicy;
-        this.Fees = solanaFeeEstimator;
+        this.config = options ?? {};
+        (_a = this.config).getLogForwardBlockRange ?? (_a.getLogForwardBlockRange = 2000);
+        (_b = this.config).getLogChunkSize ?? (_b.getLogChunkSize = 100);
+        (_c = this.config).maxGetLogKeys ?? (_c.maxGetLogKeys = 64);
+        (_d = this.config).maxParallelCalls ?? (_d.maxParallelCalls = 10);
+        this.Fees = feeEstimator;
         this.Tokens = new StarknetTokens_1.StarknetTokens(this);
         this.Transactions = new StarknetTransactions_1.StarknetTransactions(this);
         this.Signatures = new StarknetSignatures_1.StarknetSignatures(this);

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

@@ -27,7 +27,7 @@ export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEv
      * @param startBlockHeight
      * @param endBlockHeight
      */
-    getContractBlockEvents<T extends ExtractAbiEventNames<TAbi>>(events: T[], keys: string[], startBlockHeight?: number, endBlockHeight?: number): Promise<StarknetAbiEvent<TAbi, T>[]>;
+    getContractBlockEvents<T extends ExtractAbiEventNames<TAbi>>(events: T[], keys: (string | string[])[], startBlockHeight?: number, endBlockHeight?: number): Promise<StarknetAbiEvent<TAbi, T>[]>;
     /**
      * Runs a search backwards in time, processing the events for a specific topic public key
      *
@@ -37,7 +37,7 @@ export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEv
      *  if the search should continue
      * @param abortSignal
      */
-    findInContractEvents<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+    findInContractEvents<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: (string | string[])[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
     /**
      * Runs a search forwards in time, processing the events for a specific topic public key
      *
@@ -47,5 +47,5 @@ export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEv
      *  if the search should continue
      * @param abortSignal
      */
-    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: (string | string[])[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
 }

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

@@ -39,7 +39,7 @@ class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
             return (0, Utils_1.toHex)(starknet_1.hash.starknetKeccak(eventName));
         }));
         if (keys != null)
-            keys.forEach(key => filterArray.push(key == null ? [] : [key]));
+            keys.forEach(key => filterArray.push(key == null ? [] : Array.isArray(key) ? key : [key]));
         return filterArray;
     }
     /**

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

@@ -31,8 +31,36 @@ export declare class StarknetSpvVaultContract extends StarknetContractBase<typeo
     checkWithdrawalTx(tx: SpvWithdrawalTransactionData): Promise<void>;
     createVaultData(owner: string, vaultId: bigint, utxo: string, confirmations: number, tokenData: SpvVaultTokenData[]): Promise<StarknetSpvVaultData>;
     getVaultData(owner: string, vaultId: bigint): Promise<StarknetSpvVaultData>;
+    getMultipleVaultData(vaults: {
+        owner: string;
+        vaultId: bigint;
+    }[]): Promise<{
+        [owner: string]: {
+            [vaultId: string]: StarknetSpvVaultData;
+        };
+    }>;
+    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<StarknetSpvVaultData[]>;
     getFronterAddress(owner: string, vaultId: bigint, withdrawal: StarknetSpvWithdrawalData): Promise<string | null>;
+    getFronterAddresses(withdrawals: {
+        owner: string;
+        vaultId: bigint;
+        withdrawal: StarknetSpvWithdrawalData;
+    }[]): Promise<{
+        [btcTxId: string]: string | null;
+    }>;
+    private parseWithdrawalEvent;
+    getWithdrawalStates(btcTxIds: string[]): Promise<{
+        [btcTxId: string]: SpvWithdrawalState;
+    }>;
     getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState>;
     getWithdrawalData(btcTx: BtcTx): Promise<StarknetSpvWithdrawalData>;
     fromOpReturnData(data: Buffer): {

package/dist/starknet/spv_swap/StarknetSpvVaultContract.js

@@ -97,6 +97,48 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
             return null;
         return new StarknetSpvVaultData_1.StarknetSpvVaultData(owner, vaultId, struct);
     }
+    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 vault = await this.getVaultData(owner, vaultId);
+        if (vault == null)
+            return null;
+        if (!vault.isOpened())
+            return null;
+        return vault.getUtxo();
+    }
+    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 Set();
         await this.Events.findInContractEventsForward(["spv_swap_vault::events::Opened", "spv_swap_vault::events::Closed"], owner == null ? null : [null, owner], (event) => {
@@ -126,6 +168,88 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
             return null;
         return fronterAddress;
     }
+    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;
+    }
+    parseWithdrawalEvent(event) {
+        switch (event.name) {
+            case "spv_swap_vault::events::Fronted":
+                return {
+                    type: base_1.SpvWithdrawalStateType.FRONTED,
+                    txId: event.txHash,
+                    owner: (0, Utils_1.toHex)(event.params.owner),
+                    vaultId: (0, Utils_1.toBigInt)(event.params.vault_id),
+                    recipient: (0, Utils_1.toHex)(event.params.recipient),
+                    fronter: (0, Utils_1.toHex)(event.params.fronting_address)
+                };
+            case "spv_swap_vault::events::Claimed":
+                return {
+                    type: base_1.SpvWithdrawalStateType.CLAIMED,
+                    txId: event.txHash,
+                    owner: (0, Utils_1.toHex)(event.params.owner),
+                    vaultId: (0, Utils_1.toBigInt)(event.params.vault_id),
+                    recipient: (0, Utils_1.toHex)(event.params.recipient),
+                    claimer: (0, Utils_1.toHex)(event.params.caller),
+                    fronter: (0, Utils_1.toHex)(event.params.fronting_address)
+                };
+            case "spv_swap_vault::events::Closed":
+                return {
+                    type: base_1.SpvWithdrawalStateType.CLOSED,
+                    txId: event.txHash,
+                    owner: (0, Utils_1.toHex)(event.params.owner),
+                    vaultId: (0, Utils_1.toBigInt)(event.params.vault_id),
+                    error: (0, Utils_1.bigNumberishToBuffer)(event.params.error).toString()
+                };
+            default:
+                return null;
+        }
+    }
+    async getWithdrawalStates(btcTxIds) {
+        const result = {};
+        btcTxIds.forEach(txId => {
+            result[txId] = {
+                type: base_1.SpvWithdrawalStateType.NOT_FOUND
+            };
+        });
+        for (let i = 0; i < btcTxIds.length; i += this.Chain.config.maxGetLogKeys) {
+            const checkBtcTxIds = btcTxIds.slice(i, i + this.Chain.config.maxGetLogKeys);
+            const lows = [];
+            const highs = [];
+            checkBtcTxIds.forEach(btcTxId => {
+                const txHash = buffer_1.Buffer.from(btcTxId, "hex").reverse();
+                const txHashU256 = starknet_1.cairo.uint256("0x" + txHash.toString("hex"));
+                lows.push((0, Utils_1.toHex)(txHashU256.low));
+                highs.push((0, Utils_1.toHex)(txHashU256.high));
+            });
+            await this.Events.findInContractEventsForward(["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"], [
+                lows,
+                highs
+            ], async (event) => {
+                const txId = (0, Utils_1.bigNumberishToBuffer)(event.params.btc_tx_hash, 32).reverse().toString("hex");
+                if (result[txId] == null) {
+                    this.logger.warn(`getWithdrawalStates(): findInContractEvents-callback: loaded event for ${txId}, but transaction not found in input params!`);
+                    return;
+                }
+                const eventResult = this.parseWithdrawalEvent(event);
+                if (eventResult != null)
+                    result[txId] = eventResult;
+            });
+        }
+        return result;
+    }
     async getWithdrawalState(btcTxId) {
         const txHash = buffer_1.Buffer.from(btcTxId, "hex").reverse();
         const txHashU256 = starknet_1.cairo.uint256("0x" + txHash.toString("hex"));
@@ -136,38 +260,9 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
             (0, Utils_1.toHex)(txHashU256.low),
             (0, Utils_1.toHex)(txHashU256.high)
         ], async (event) => {
-            switch (event.name) {
-                case "spv_swap_vault::events::Fronted":
-                    result = {
-                        type: base_1.SpvWithdrawalStateType.FRONTED,
-                        txId: event.txHash,
-                        owner: (0, Utils_1.toHex)(event.params.owner),
-                        vaultId: (0, Utils_1.toBigInt)(event.params.vault_id),
-                        recipient: (0, Utils_1.toHex)(event.params.recipient),
-                        fronter: (0, Utils_1.toHex)(event.params.fronting_address)
-                    };
-                    break;
-                case "spv_swap_vault::events::Claimed":
-                    result = {
-                        type: base_1.SpvWithdrawalStateType.CLAIMED,
-                        txId: event.txHash,
-                        owner: (0, Utils_1.toHex)(event.params.owner),
-                        vaultId: (0, Utils_1.toBigInt)(event.params.vault_id),
-                        recipient: (0, Utils_1.toHex)(event.params.recipient),
-                        claimer: (0, Utils_1.toHex)(event.params.caller),
-                        fronter: (0, Utils_1.toHex)(event.params.fronting_address)
-                    };
-                    break;
-                case "spv_swap_vault::events::Closed":
-                    result = {
-                        type: base_1.SpvWithdrawalStateType.CLOSED,
-                        txId: event.txHash,
-                        owner: (0, Utils_1.toHex)(event.params.owner),
-                        vaultId: (0, Utils_1.toBigInt)(event.params.vault_id),
-                        error: (0, Utils_1.bigNumberishToBuffer)(event.params.error).toString()
-                    };
-                    break;
-            }
+            const eventResult = this.parseWithdrawalEvent(event);
+            if (eventResult != null)
+                result = eventResult;
         });
         return result;
     }

package/dist/starknet/swaps/StarknetSwapContract.d.ts

@@ -126,6 +126,12 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
      * @param data
      */
     getCommitStatus(signer: string, data: StarknetSwapData): Promise<SwapCommitState>;
+    getCommitStatuses(request: {
+        signer: string;
+        swapData: StarknetSwapData;
+    }[]): 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/starknet/swaps/StarknetSwapContract.js

@@ -287,6 +287,22 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
                 };
         }
     }
+    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/package.json

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

package/src/starknet/StarknetInitializer.ts

@@ -1,6 +1,6 @@
 import {constants, Provider} from "starknet";
 import {StarknetFees} from "./chain/modules/StarknetFees";
-import {StarknetChainInterface, StarknetRetryPolicy} from "./chain/StarknetChainInterface";
+import {StarknetChainInterface, StarknetConfig, StarknetRetryPolicy} from "./chain/StarknetChainInterface";
 import {StarknetBtcRelay} from "./btcrelay/StarknetBtcRelay";
 import {StarknetSwapContract} from "./swaps/StarknetSwapContract";
 import {StarknetChainEventsBrowser} from "./events/StarknetChainEventsBrowser";
@@ -52,7 +52,9 @@ export type StarknetOptions = {
         }
     }
 
-    fees?: StarknetFees
+    fees?: StarknetFees,
+
+    starknetConfig?: StarknetConfig
 }
 
 export function initializeStarknet(
@@ -69,7 +71,7 @@ export function initializeStarknet(
     const chainId = options.chainId ??
         (network===BitcoinNetwork.MAINNET ? constants.StarknetChainId.SN_MAIN : constants.StarknetChainId.SN_SEPOLIA);
 
-    const chainInterface = new StarknetChainInterface(chainId, provider, options.retryPolicy, Fees);
+    const chainInterface = new StarknetChainInterface(chainId, provider, options.retryPolicy, Fees, options.starknetConfig);
 
     const btcRelay = new StarknetBtcRelay(
         chainInterface, bitcoinRpc, network, options.btcRelayContract

package/src/starknet/chain/StarknetChainInterface.ts

@@ -19,6 +19,14 @@ export type StarknetRetryPolicy = {
     exponential?: boolean
 }
 
+export type StarknetConfig = {
+    getLogChunkSize?: number, //100
+    getLogForwardBlockRange?: number, //2000
+    maxGetLogKeys?: number, //64
+
+    maxParallelCalls?: number, //10
+};
+
 export class StarknetChainInterface implements ChainInterface {
 
     readonly chainId = "STARKNET";
@@ -38,17 +46,25 @@ export class StarknetChainInterface implements ChainInterface {
 
     protected readonly logger = getLogger("StarknetChainInterface: ");
 
+    public readonly config: StarknetConfig;
+
     constructor(
         chainId: constants.StarknetChainId,
         provider: Provider,
         retryPolicy?: StarknetRetryPolicy,
-        solanaFeeEstimator: StarknetFees = new StarknetFees(provider)
+        feeEstimator: StarknetFees = new StarknetFees(provider),
+        options?: StarknetConfig
     ) {
         this.starknetChainId = chainId;
         this.provider = provider;
         this.retryPolicy = retryPolicy;
+        this.config = options ?? {};
+        this.config.getLogForwardBlockRange ??= 2000;
+        this.config.getLogChunkSize ??= 100;
+        this.config.maxGetLogKeys ??= 64;
+        this.config.maxParallelCalls ??= 10;
 
-        this.Fees = solanaFeeEstimator;
+        this.Fees = feeEstimator;
         this.Tokens = new StarknetTokens(this);
         this.Transactions = new StarknetTransactions(this);
 

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

@@ -51,7 +51,7 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
 
     private toFilter<T extends ExtractAbiEventNames<TAbi>>(
         events: T[],
-        keys: string[],
+        keys: (string | string[])[],
     ): string[][] {
         const filterArray: string[][] = [];
         filterArray.push(events.map(name => {
@@ -59,7 +59,7 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
             const eventName = arr[arr.length-1];
             return toHex(hash.starknetKeccak(eventName))
         }));
-        if(keys!=null) keys.forEach(key => filterArray.push(key==null ? [] : [key]));
+        if(keys!=null) keys.forEach(key => filterArray.push(key==null ? [] : Array.isArray(key) ? key : [key]));
         return filterArray;
     }
 
@@ -74,7 +74,7 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
      */
     public async getContractBlockEvents<T extends ExtractAbiEventNames<TAbi>>(
         events: T[],
-        keys: string[],
+        keys: (string | string[])[],
         startBlockHeight?: number,
         endBlockHeight: number = startBlockHeight
     ): Promise<StarknetAbiEvent<TAbi, T>[]> {
@@ -93,7 +93,7 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
      */
     public async findInContractEvents<T, TEvent extends ExtractAbiEventNames<TAbi>>(
         events: TEvent[],
-        keys: string[],
+        keys: (string | string[])[],
         processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>,
         abortSignal?: AbortSignal
     ) {
@@ -117,7 +117,7 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
      */
     public async findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(
         events: TEvent[],
-        keys: string[],
+        keys: (string | string[])[],
         processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>,
         abortSignal?: AbortSignal
     ) {

package/src/starknet/spv_swap/StarknetSpvVaultContract.ts

@@ -6,7 +6,7 @@ import {
     SpvVaultTokenData,
     SpvWithdrawalState,
     SpvWithdrawalStateType,
-    SpvWithdrawalTransactionData,
+    SpvWithdrawalTransactionData, SwapCommitState,
     TransactionConfirmationOptions
 } from "@atomiqlabs/base";
 import {Buffer} from "buffer";
@@ -24,6 +24,9 @@ import {bigNumberishToBuffer, bufferToByteArray, bufferToU32Array, getLogger, to
 import {StarknetBtcStoredHeader} from "../btcrelay/headers/StarknetBtcStoredHeader";
 import {StarknetAddresses} from "../chain/modules/StarknetAddresses";
 import {StarknetFees} from "../chain/modules/StarknetFees";
+import {toBig} from "@noble/hashes/_u64";
+import {StarknetAbiEvent} from "../contract/modules/StarknetContractEvents";
+import {ExtractAbiEventNames} from "abi-wan-kanabi/dist/kanabi";
 
 const spvVaultContractAddreses = {
     [constants.StarknetChainId.SN_SEPOLIA]: "0x02d581ea838cd5ca46ba08660eddd064d50a0392f618e95310432147928d572e",
@@ -166,6 +169,49 @@ export class StarknetSpvVaultContract
         return new StarknetSpvVaultData(owner, vaultId, struct);
     }
 
+    async getMultipleVaultData(vaults: {owner: string, vaultId: bigint}[]): Promise<{[owner: string]: {[vaultId: string]: StarknetSpvVaultData}}> {
+        const result: {[owner: string]: {[vaultId: string]: StarknetSpvVaultData}} = {};
+        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 vault = await this.getVaultData(owner, vaultId);
+        if(vault==null) return null;
+        if(!vault.isOpened()) return null;
+        return vault.getUtxo();
+    }
+
+    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<StarknetSpvVaultData[]> {
         const openedVaults = new Set<string>();
         await this.Events.findInContractEventsForward(
@@ -198,6 +244,98 @@ export class StarknetSpvVaultContract
         return fronterAddress;
     }
 
+    async getFronterAddresses(withdrawals: {owner: string, vaultId: bigint, withdrawal: StarknetSpvWithdrawalData}[]): 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 parseWithdrawalEvent(event: StarknetAbiEvent<typeof SpvVaultContractAbi, "spv_swap_vault::events::Claimed" | "spv_swap_vault::events::Fronted" | "spv_swap_vault::events::Closed">): SpvWithdrawalState | null {
+        switch(event.name) {
+            case "spv_swap_vault::events::Fronted":
+                return {
+                    type: SpvWithdrawalStateType.FRONTED,
+                    txId: event.txHash,
+                    owner: toHex(event.params.owner),
+                    vaultId: toBigInt(event.params.vault_id),
+                    recipient: toHex(event.params.recipient),
+                    fronter: toHex(event.params.fronting_address)
+                };
+            case "spv_swap_vault::events::Claimed":
+                return {
+                    type: SpvWithdrawalStateType.CLAIMED,
+                    txId: event.txHash,
+                    owner: toHex(event.params.owner),
+                    vaultId: toBigInt(event.params.vault_id),
+                    recipient: toHex(event.params.recipient),
+                    claimer: toHex(event.params.caller),
+                    fronter: toHex(event.params.fronting_address)
+                };
+            case "spv_swap_vault::events::Closed":
+                return {
+                    type: SpvWithdrawalStateType.CLOSED,
+                    txId: event.txHash,
+                    owner: toHex(event.params.owner),
+                    vaultId: toBigInt(event.params.vault_id),
+                    error: bigNumberishToBuffer(event.params.error).toString()
+                };
+            default:
+                return null;
+        }
+    }
+
+    async getWithdrawalStates(btcTxIds: string[]): Promise<{[btcTxId: string]: SpvWithdrawalState}> {
+        const result: {[btcTxId: string]: SpvWithdrawalState} = {};
+        btcTxIds.forEach(txId => {
+            result[txId] = {
+                type: SpvWithdrawalStateType.NOT_FOUND
+            };
+        });
+
+        for(let i=0;i<btcTxIds.length;i+=this.Chain.config.maxGetLogKeys) {
+            const checkBtcTxIds = btcTxIds.slice(i, i+this.Chain.config.maxGetLogKeys);
+            const lows: string[] = [];
+            const highs: string[] = [];
+            checkBtcTxIds.forEach(btcTxId => {
+                const txHash = Buffer.from(btcTxId, "hex").reverse();
+                const txHashU256 = cairo.uint256("0x"+txHash.toString("hex"));
+                lows.push(toHex(txHashU256.low));
+                highs.push(toHex(txHashU256.high));
+            });
+            await this.Events.findInContractEventsForward(
+                ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"],
+                [
+                    lows,
+                    highs
+                ],
+                async (event) => {
+                    const txId = bigNumberishToBuffer(event.params.btc_tx_hash, 32).reverse().toString("hex");
+                    if(result[txId]==null) {
+                        this.logger.warn(`getWithdrawalStates(): findInContractEvents-callback: loaded event for ${txId}, but transaction not found in input params!`)
+                        return;
+                    }
+                    const eventResult = this.parseWithdrawalEvent(event);
+                    if(eventResult!=null) result[txId] = eventResult;
+                }
+            );
+        }
+
+        return result;
+    }
+
     async getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState> {
         const txHash = Buffer.from(btcTxId, "hex").reverse();
         const txHashU256 = cairo.uint256("0x"+txHash.toString("hex"));
@@ -211,38 +349,8 @@ export class StarknetSpvVaultContract
                 toHex(txHashU256.high)
             ],
             async (event) => {
-                switch(event.name) {
-                    case "spv_swap_vault::events::Fronted":
-                        result = {
-                            type: SpvWithdrawalStateType.FRONTED,
-                            txId: event.txHash,
-                            owner: toHex(event.params.owner),
-                            vaultId: toBigInt(event.params.vault_id),
-                            recipient: toHex(event.params.recipient),
-                            fronter: toHex(event.params.fronting_address)
-                        };
-                        break;
-                    case "spv_swap_vault::events::Claimed":
-                        result = {
-                            type: SpvWithdrawalStateType.CLAIMED,
-                            txId: event.txHash,
-                            owner: toHex(event.params.owner),
-                            vaultId: toBigInt(event.params.vault_id),
-                            recipient: toHex(event.params.recipient),
-                            claimer: toHex(event.params.caller),
-                            fronter: toHex(event.params.fronting_address)
-                        };
-                        break;
-                    case "spv_swap_vault::events::Closed":
-                        result = {
-                            type: SpvWithdrawalStateType.CLOSED,
-                            txId: event.txHash,
-                            owner: toHex(event.params.owner),
-                            vaultId: toBigInt(event.params.vault_id),
-                            error: bigNumberishToBuffer(event.params.error).toString()
-                        }
-                        break;
-                }
+                const eventResult = this.parseWithdrawalEvent(event);
+                if(eventResult!=null) result = eventResult;
             }
         );
         return result;

package/src/starknet/swaps/StarknetSwapContract.ts

@@ -369,6 +369,27 @@ export class StarknetSwapContract
         }
     }
 
+    async getCommitStatuses(request: { signer: string; swapData: StarknetSwapData }[]): 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