@arkade-os/sdk 0.3.7 → 0.3.9

package/dist/esm/wallet/wallet.js

@@ -1,92 +1,58 @@
 import { base64, hex } from "@scure/base";
 import * as bip68 from "bip68";
 import { tapLeafHash } from "@scure/btc-signer/payment.js";
-import { SigHash, Transaction, Address, OutScript, } from "@scure/btc-signer";
+import { SigHash, Transaction, Address, OutScript } from "@scure/btc-signer";
 import { sha256 } from "@scure/btc-signer/utils.js";
 import { vtxosToTxs } from '../utils/transactionHistory.js';
 import { ArkAddress } from '../script/address.js';
 import { DefaultVtxo } from '../script/default.js';
 import { getNetwork } from '../networks.js';
 import { ESPLORA_URL, EsploraProvider, } from '../providers/onchain.js';
-import { SettlementEventType, RestArkProvider, } from '../providers/ark.js';
+import { RestArkProvider, } from '../providers/ark.js';
 import { buildForfeitTx } from '../forfeit.js';
 import { validateConnectorsTxGraph, validateVtxoTxGraph, } from '../tree/validation.js';
-import { isRecoverable, isSpendable, isSubdust, TxType, } from './index.js';
+import { isExpired, isRecoverable, isSpendable, isSubdust, TxType, } from './index.js';
 import { VtxoScript } from '../script/base.js';
-import { CSVMultisigTapscript } from '../script/tapscript.js';
+import { CLTVMultisigTapscript, CSVMultisigTapscript, } from '../script/tapscript.js';
 import { buildOffchainTx, hasBoardingTxExpired } from '../utils/arkTransaction.js';
 import { DEFAULT_RENEWAL_CONFIG } from './vtxo-manager.js';
 import { ArkNote } from '../arknote/index.js';
 import { Intent } from '../intent/index.js';
 import { RestIndexerProvider } from '../providers/indexer.js';
-import { TxTree } from '../tree/txTree.js';
 import { ConditionWitness, VtxoTaprootTree } from '../utils/unknownFields.js';
 import { InMemoryStorageAdapter } from '../storage/inMemory.js';
 import { WalletRepositoryImpl, } from '../repositories/walletRepository.js';
 import { ContractRepositoryImpl, } from '../repositories/contractRepository.js';
 import { extendCoin, extendVirtualCoin } from './utils.js';
 import { ArkError } from '../providers/errors.js';
+import { Batch } from './batch.js';
 /**
- * Main wallet implementation for Bitcoin transactions with Ark protocol support.
- * The wallet does not store any data locally and relies on Ark and onchain
- * providers to fetch UTXOs and VTXOs.
- *
- * @example
- * ```typescript
- * // Create a wallet with URL configuration
- * const wallet = await Wallet.create({
- *   identity: SingleKey.fromHex('your_private_key'),
- *   arkServerUrl: 'https://ark.example.com',
- *   esploraUrl: 'https://mempool.space/api'
- * });
- *
- * // Or with custom provider instances (e.g., for Expo/React Native)
- * const wallet = await Wallet.create({
- *   identity: SingleKey.fromHex('your_private_key'),
- *   arkProvider: new ExpoArkProvider('https://ark.example.com'),
- *   indexerProvider: new ExpoIndexerProvider('https://ark.example.com'),
- *   esploraUrl: 'https://mempool.space/api'
- * });
- *
- * // Get addresses
- * const arkAddress = await wallet.getAddress();
- * const boardingAddress = await wallet.getBoardingAddress();
- *
- * // Send bitcoin
- * const txid = await wallet.sendBitcoin({
- *   address: 'tb1...',
- *   amount: 50000
- * });
- * ```
+ * Type guard function to check if an identity has a toReadonly method.
  */
-export class Wallet {
-    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, renewalConfig) {
+function hasToReadonly(identity) {
+    return (typeof identity === "object" &&
+        identity !== null &&
+        "toReadonly" in identity &&
+        typeof identity.toReadonly === "function");
+}
+export class ReadonlyWallet {
+    constructor(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository) {
         this.identity = identity;
         this.network = network;
-        this.networkName = networkName;
         this.onchainProvider = onchainProvider;
-        this.arkProvider = arkProvider;
         this.indexerProvider = indexerProvider;
         this.arkServerPublicKey = arkServerPublicKey;
         this.offchainTapscript = offchainTapscript;
         this.boardingTapscript = boardingTapscript;
-        this.serverUnrollScript = serverUnrollScript;
-        this.forfeitOutputScript = forfeitOutputScript;
-        this.forfeitPubkey = forfeitPubkey;
         this.dustAmount = dustAmount;
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
-        this.renewalConfig = {
-            enabled: renewalConfig?.enabled ?? false,
-            ...DEFAULT_RENEWAL_CONFIG,
-            ...renewalConfig,
-        };
     }
-    static async create(config) {
-        const pubkey = await config.identity.xOnlyPublicKey();
-        if (!pubkey) {
-            throw new Error("Invalid configured public key");
-        }
+    /**
+     * Protected helper to set up shared wallet configuration.
+     * Extracts common logic used by both ReadonlyWallet.create() and Wallet.create().
+     */
+    static async setupWalletConfig(config, pubkey) {
         // Use provided arkProvider instance or create a new one from arkServerUrl
         const arkProvider = config.arkProvider ||
             (() => {
@@ -150,25 +116,32 @@ export class Wallet {
         });
         // Save tapscripts
         const offchainTapscript = bareVtxoTapscript;
-        // the serverUnrollScript is the one used to create output scripts of the checkpoint transactions
-        let serverUnrollScript;
-        try {
-            const raw = hex.decode(info.checkpointTapscript);
-            serverUnrollScript = CSVMultisigTapscript.decode(raw);
-        }
-        catch (e) {
-            throw new Error("Invalid checkpointTapscript from server");
-        }
-        // parse the server forfeit address
-        // server is expecting funds to be sent to this address
-        const forfeitPubkey = hex.decode(info.forfeitPubkey).slice(1);
-        const forfeitAddress = Address(network).decode(info.forfeitAddress);
-        const forfeitOutputScript = OutScript.encode(forfeitAddress);
         // Set up storage and repositories
         const storage = config.storage || new InMemoryStorageAdapter();
         const walletRepository = new WalletRepositoryImpl(storage);
         const contractRepository = new ContractRepositoryImpl(storage);
-        return new Wallet(config.identity, network, info.network, onchainProvider, arkProvider, indexerProvider, serverPubKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, info.dust, walletRepository, contractRepository, config.renewalConfig);
+        return {
+            arkProvider,
+            indexerProvider,
+            onchainProvider,
+            network,
+            networkName: info.network,
+            serverPubKey,
+            offchainTapscript,
+            boardingTapscript,
+            dustAmount: info.dust,
+            walletRepository,
+            contractRepository,
+            info,
+        };
+    }
+    static async create(config) {
+        const pubkey = await config.identity.xOnlyPublicKey();
+        if (!pubkey) {
+            throw new Error("Invalid configured public key");
+        }
+        const setup = await ReadonlyWallet.setupWalletConfig(config, pubkey);
+        return new ReadonlyWallet(config.identity, setup.network, setup.onchainProvider, setup.indexerProvider, setup.serverPubKey, setup.offchainTapscript, setup.boardingTapscript, setup.dustAmount, setup.walletRepository, setup.contractRepository);
     }
     get arkAddress() {
         return this.offchainTapscript.address(this.network.hrp, this.arkServerPublicKey);
@@ -243,7 +216,7 @@ export class Wallet {
         let vtxos = allVtxos.filter(isSpendable);
         // all recoverable vtxos are spendable by definition
         if (!filter.withRecoverable) {
-            vtxos = vtxos.filter((vtxo) => !isRecoverable(vtxo));
+            vtxos = vtxos.filter((vtxo) => !isRecoverable(vtxo) && !isExpired(vtxo));
         }
         if (filter.withUnrolled) {
             const spentVtxos = allVtxos.filter((vtxo) => !isSpendable(vtxo));
@@ -252,9 +225,6 @@ export class Wallet {
         return vtxos;
     }
     async getTransactionHistory() {
-        if (!this.indexerProvider) {
-            return [];
-        }
         const response = await this.indexerProvider.getVtxos({
             scripts: [hex.encode(this.offchainTapscript.pkScript)],
         });
@@ -358,6 +328,178 @@ export class Wallet {
         await this.walletRepository.saveUtxos(boardingAddress, utxos);
         return utxos;
     }
+    async notifyIncomingFunds(eventCallback) {
+        const arkAddress = await this.getAddress();
+        const boardingAddress = await this.getBoardingAddress();
+        let onchainStopFunc;
+        let indexerStopFunc;
+        if (this.onchainProvider && boardingAddress) {
+            const findVoutOnTx = (tx) => {
+                return tx.vout.findIndex((v) => v.scriptpubkey_address === boardingAddress);
+            };
+            onchainStopFunc = await this.onchainProvider.watchAddresses([boardingAddress], (txs) => {
+                // find all utxos belonging to our boarding address
+                const coins = txs
+                    // filter txs where address is in output
+                    .filter((tx) => findVoutOnTx(tx) !== -1)
+                    // return utxo as Coin
+                    .map((tx) => {
+                    const { txid, status } = tx;
+                    const vout = findVoutOnTx(tx);
+                    const value = Number(tx.vout[vout].value);
+                    return { txid, vout, value, status };
+                });
+                // and notify via callback
+                eventCallback({
+                    type: "utxo",
+                    coins,
+                });
+            });
+        }
+        if (this.indexerProvider && arkAddress) {
+            const offchainScript = this.offchainTapscript;
+            const subscriptionId = await this.indexerProvider.subscribeForScripts([
+                hex.encode(offchainScript.pkScript),
+            ]);
+            const abortController = new AbortController();
+            const subscription = this.indexerProvider.getSubscription(subscriptionId, abortController.signal);
+            indexerStopFunc = async () => {
+                abortController.abort();
+                await this.indexerProvider?.unsubscribeForScripts(subscriptionId);
+            };
+            // Handle subscription updates asynchronously without blocking
+            (async () => {
+                try {
+                    for await (const update of subscription) {
+                        if (update.newVtxos?.length > 0 ||
+                            update.spentVtxos?.length > 0) {
+                            eventCallback({
+                                type: "vtxo",
+                                newVtxos: update.newVtxos.map((vtxo) => extendVirtualCoin(this, vtxo)),
+                                spentVtxos: update.spentVtxos.map((vtxo) => extendVirtualCoin(this, vtxo)),
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error("Subscription error:", error);
+                }
+            })();
+        }
+        const stopFunc = () => {
+            onchainStopFunc?.();
+            indexerStopFunc?.();
+        };
+        return stopFunc;
+    }
+    async fetchPendingTxs() {
+        // get non-swept VTXOs, rely on the indexer only in case DB doesn't have the right state
+        const scripts = [hex.encode(this.offchainTapscript.pkScript)];
+        let { vtxos } = await this.indexerProvider.getVtxos({
+            scripts,
+        });
+        return vtxos
+            .filter((vtxo) => vtxo.virtualStatus.state !== "swept" &&
+            vtxo.virtualStatus.state !== "settled" &&
+            vtxo.arkTxId !== undefined)
+            .map((_) => _.arkTxId);
+    }
+}
+/**
+ * Main wallet implementation for Bitcoin transactions with Ark protocol support.
+ * The wallet does not store any data locally and relies on Ark and onchain
+ * providers to fetch UTXOs and VTXOs.
+ *
+ * @example
+ * ```typescript
+ * // Create a wallet with URL configuration
+ * const wallet = await Wallet.create({
+ *   identity: SingleKey.fromHex('your_private_key'),
+ *   arkServerUrl: 'https://ark.example.com',
+ *   esploraUrl: 'https://mempool.space/api'
+ * });
+ *
+ * // Or with custom provider instances (e.g., for Expo/React Native)
+ * const wallet = await Wallet.create({
+ *   identity: SingleKey.fromHex('your_private_key'),
+ *   arkProvider: new ExpoArkProvider('https://ark.example.com'),
+ *   indexerProvider: new ExpoIndexerProvider('https://ark.example.com'),
+ *   esploraUrl: 'https://mempool.space/api'
+ * });
+ *
+ * // Get addresses
+ * const arkAddress = await wallet.getAddress();
+ * const boardingAddress = await wallet.getBoardingAddress();
+ *
+ * // Send bitcoin
+ * const txid = await wallet.sendBitcoin({
+ *   address: 'tb1...',
+ *   amount: 50000
+ * });
+ * ```
+ */
+export class Wallet extends ReadonlyWallet {
+    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, renewalConfig) {
+        super(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository);
+        this.networkName = networkName;
+        this.arkProvider = arkProvider;
+        this.serverUnrollScript = serverUnrollScript;
+        this.forfeitOutputScript = forfeitOutputScript;
+        this.forfeitPubkey = forfeitPubkey;
+        this.identity = identity;
+        this.renewalConfig = {
+            enabled: renewalConfig?.enabled ?? false,
+            ...DEFAULT_RENEWAL_CONFIG,
+            ...renewalConfig,
+        };
+    }
+    static async create(config) {
+        const pubkey = await config.identity.xOnlyPublicKey();
+        if (!pubkey) {
+            throw new Error("Invalid configured public key");
+        }
+        const setup = await ReadonlyWallet.setupWalletConfig(config, pubkey);
+        // Compute Wallet-specific forfeit and unroll scripts
+        // the serverUnrollScript is the one used to create output scripts of the checkpoint transactions
+        let serverUnrollScript;
+        try {
+            const raw = hex.decode(setup.info.checkpointTapscript);
+            serverUnrollScript = CSVMultisigTapscript.decode(raw);
+        }
+        catch (e) {
+            throw new Error("Invalid checkpointTapscript from server");
+        }
+        // parse the server forfeit address
+        // server is expecting funds to be sent to this address
+        const forfeitPubkey = hex.decode(setup.info.forfeitPubkey).slice(1);
+        const forfeitAddress = Address(setup.network).decode(setup.info.forfeitAddress);
+        const forfeitOutputScript = OutScript.encode(forfeitAddress);
+        return new Wallet(config.identity, setup.network, setup.networkName, setup.onchainProvider, setup.arkProvider, setup.indexerProvider, setup.serverPubKey, setup.offchainTapscript, setup.boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, setup.dustAmount, setup.walletRepository, setup.contractRepository, config.renewalConfig);
+    }
+    /**
+     * Convert this wallet to a readonly wallet.
+     *
+     * @returns A readonly wallet with the same configuration but readonly identity
+     * @example
+     * ```typescript
+     * const wallet = await Wallet.create({ identity: SingleKey.fromHex('...'), ... });
+     * const readonlyWallet = await wallet.toReadonly();
+     *
+     * // Can query balance and addresses
+     * const balance = await readonlyWallet.getBalance();
+     * const address = await readonlyWallet.getAddress();
+     *
+     * // But cannot send transactions (type error)
+     * // readonlyWallet.sendBitcoin(...); // TypeScript error
+     * ```
+     */
+    async toReadonly() {
+        // Check if the identity has a toReadonly method using type guard
+        const readonlyIdentity = hasToReadonly(this.identity)
+            ? await this.identity.toReadonly()
+            : this.identity; // Identity extends ReadonlyIdentity, so this is safe
+        return new ReadonlyWallet(readonlyIdentity, this.network, this.onchainProvider, this.indexerProvider, this.arkServerPublicKey, this.offchainTapscript, this.boardingTapscript, this.dustAmount, this.walletRepository, this.contractRepository);
+    }
     async sendBitcoin(params) {
         if (params.amount <= 0) {
             throw new Error("Amount must be positive");
@@ -444,7 +586,7 @@ export class Wallet {
                     vout: outputs.length - 1,
                     createdAt: new Date(createdAt),
                     forfeitTapLeafScript: this.offchainTapscript.forfeit(),
-                    intentTapLeafScript: this.offchainTapscript.exit(),
+                    intentTapLeafScript: this.offchainTapscript.forfeit(),
                     isUnrolled: false,
                     isSpent: false,
                     tapTree: this.offchainTapscript.encode(),
@@ -554,285 +696,31 @@ export class Wallet {
             this.makeDeleteIntentSignature(params.inputs),
         ]);
         const intentId = await this.safeRegisterIntent(intent);
+        const topics = [
+            ...signingPublicKeys,
+            ...params.inputs.map((input) => `${input.txid}:${input.vout}`),
+        ];
+        const handler = this.createBatchHandler(intentId, params.inputs, session);
         const abortController = new AbortController();
-        // listen to settlement events
         try {
-            let step;
-            const topics = [
-                ...signingPublicKeys,
-                ...params.inputs.map((input) => `${input.txid}:${input.vout}`),
-            ];
-            const settlementStream = this.arkProvider.getEventStream(abortController.signal, topics);
-            // batchId, sweepTapTreeRoot and forfeitOutputScript are set once the BatchStarted event is received
-            let batchId;
-            let sweepTapTreeRoot;
-            const vtxoChunks = [];
-            const connectorsChunks = [];
-            let vtxoGraph;
-            let connectorsGraph;
-            for await (const event of settlementStream) {
-                if (eventCallback) {
-                    eventCallback(event);
-                }
-                switch (event.type) {
-                    // the settlement failed
-                    case SettlementEventType.BatchFailed:
-                        throw new Error(event.reason);
-                    case SettlementEventType.BatchStarted:
-                        if (step !== undefined) {
-                            continue;
-                        }
-                        const res = await this.handleBatchStartedEvent(event, intentId, this.forfeitPubkey, this.forfeitOutputScript);
-                        if (!res.skip) {
-                            step = event.type;
-                            sweepTapTreeRoot = res.sweepTapTreeRoot;
-                            batchId = res.roundId;
-                            if (!hasOffchainOutputs) {
-                                // if there are no offchain outputs, we don't have to handle musig2 tree signatures
-                                // we can directly advance to the finalization step
-                                step = SettlementEventType.TreeNonces;
-                            }
-                        }
-                        break;
-                    case SettlementEventType.TreeTx:
-                        if (step !== SettlementEventType.BatchStarted &&
-                            step !== SettlementEventType.TreeNonces) {
-                            continue;
-                        }
-                        // index 0 = vtxo tree
-                        if (event.batchIndex === 0) {
-                            vtxoChunks.push(event.chunk);
-                            // index 1 = connectors tree
-                        }
-                        else if (event.batchIndex === 1) {
-                            connectorsChunks.push(event.chunk);
-                        }
-                        else {
-                            throw new Error(`Invalid batch index: ${event.batchIndex}`);
-                        }
-                        break;
-                    case SettlementEventType.TreeSignature:
-                        if (step !== SettlementEventType.TreeNonces) {
-                            continue;
-                        }
-                        if (!hasOffchainOutputs) {
-                            continue;
-                        }
-                        if (!vtxoGraph) {
-                            throw new Error("Vtxo graph not set, something went wrong");
-                        }
-                        // index 0 = vtxo graph
-                        if (event.batchIndex === 0) {
-                            const tapKeySig = hex.decode(event.signature);
-                            vtxoGraph.update(event.txid, (tx) => {
-                                tx.updateInput(0, {
-                                    tapKeySig,
-                                });
-                            });
-                        }
-                        break;
-                    // the server has started the signing process of the vtxo tree transactions
-                    // the server expects the partial musig2 nonces for each tx
-                    case SettlementEventType.TreeSigningStarted:
-                        if (step !== SettlementEventType.BatchStarted) {
-                            continue;
-                        }
-                        if (hasOffchainOutputs) {
-                            if (!session) {
-                                throw new Error("Signing session not set");
-                            }
-                            if (!sweepTapTreeRoot) {
-                                throw new Error("Sweep tap tree root not set");
-                            }
-                            if (vtxoChunks.length === 0) {
-                                throw new Error("unsigned vtxo graph not received");
-                            }
-                            vtxoGraph = TxTree.create(vtxoChunks);
-                            await this.handleSettlementSigningEvent(event, sweepTapTreeRoot, session, vtxoGraph);
-                        }
-                        step = event.type;
-                        break;
-                    // the musig2 nonces of the vtxo tree transactions are generated
-                    // the server expects now the partial musig2 signatures
-                    case SettlementEventType.TreeNonces:
-                        if (step !== SettlementEventType.TreeSigningStarted) {
-                            continue;
-                        }
-                        if (hasOffchainOutputs) {
-                            if (!session) {
-                                throw new Error("Signing session not set");
-                            }
-                            const signed = await this.handleSettlementTreeNoncesEvent(event, session);
-                            if (signed) {
-                                step = event.type;
-                            }
-                            break;
-                        }
-                        step = event.type;
-                        break;
-                    // the vtxo tree is signed, craft, sign and submit forfeit transactions
-                    // if any boarding utxos are involved, the settlement tx is also signed
-                    case SettlementEventType.BatchFinalization:
-                        if (step !== SettlementEventType.TreeNonces) {
-                            continue;
-                        }
-                        if (!this.forfeitOutputScript) {
-                            throw new Error("Forfeit output script not set");
-                        }
-                        if (connectorsChunks.length > 0) {
-                            connectorsGraph = TxTree.create(connectorsChunks);
-                            validateConnectorsTxGraph(event.commitmentTx, connectorsGraph);
-                        }
-                        await this.handleSettlementFinalizationEvent(event, params.inputs, this.forfeitOutputScript, connectorsGraph);
-                        step = event.type;
-                        break;
-                    // the settlement is done, last event to be received
-                    case SettlementEventType.BatchFinalized:
-                        if (step !== SettlementEventType.BatchFinalization) {
-                            continue;
-                        }
-                        if (event.id === batchId) {
-                            abortController.abort();
-                            return event.commitmentTxid;
-                        }
-                }
-            }
+            const stream = this.arkProvider.getEventStream(abortController.signal, topics);
+            return await Batch.join(stream, handler, {
+                abortController,
+                skipVtxoTreeSigning: !hasOffchainOutputs,
+                eventCallback: eventCallback
+                    ? (event) => Promise.resolve(eventCallback(event))
+                    : undefined,
+            });
         }
         catch (error) {
-            // close the stream
-            abortController.abort();
-            try {
-                // delete the intent to not be stuck in the queue
-                await this.arkProvider.deleteIntent(deleteIntent);
-            }
-            catch (error) {
-                console.error("failed to delete intent: ", error);
-            }
+            // delete the intent to not be stuck in the queue
+            await this.arkProvider.deleteIntent(deleteIntent).catch(() => { });
             throw error;
         }
-        throw new Error("Settlement failed");
-    }
-    async notifyIncomingFunds(eventCallback) {
-        const arkAddress = await this.getAddress();
-        const boardingAddress = await this.getBoardingAddress();
-        let onchainStopFunc;
-        let indexerStopFunc;
-        if (this.onchainProvider && boardingAddress) {
-            const findVoutOnTx = (tx) => {
-                return tx.vout.findIndex((v) => v.scriptpubkey_address === boardingAddress);
-            };
-            onchainStopFunc = await this.onchainProvider.watchAddresses([boardingAddress], (txs) => {
-                // find all utxos belonging to our boarding address
-                const coins = txs
-                    // filter txs where address is in output
-                    .filter((tx) => findVoutOnTx(tx) !== -1)
-                    // return utxo as Coin
-                    .map((tx) => {
-                    const { txid, status } = tx;
-                    const vout = findVoutOnTx(tx);
-                    const value = Number(tx.vout[vout].value);
-                    return { txid, vout, value, status };
-                });
-                // and notify via callback
-                eventCallback({
-                    type: "utxo",
-                    coins,
-                });
-            });
-        }
-        if (this.indexerProvider && arkAddress) {
-            const offchainScript = this.offchainTapscript;
-            const subscriptionId = await this.indexerProvider.subscribeForScripts([
-                hex.encode(offchainScript.pkScript),
-            ]);
-            const abortController = new AbortController();
-            const subscription = this.indexerProvider.getSubscription(subscriptionId, abortController.signal);
-            indexerStopFunc = async () => {
-                abortController.abort();
-                await this.indexerProvider?.unsubscribeForScripts(subscriptionId);
-            };
-            // Handle subscription updates asynchronously without blocking
-            (async () => {
-                try {
-                    for await (const update of subscription) {
-                        if (update.newVtxos?.length > 0 ||
-                            update.spentVtxos?.length > 0) {
-                            eventCallback({
-                                type: "vtxo",
-                                newVtxos: update.newVtxos.map((vtxo) => extendVirtualCoin(this, vtxo)),
-                                spentVtxos: update.spentVtxos.map((vtxo) => extendVirtualCoin(this, vtxo)),
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error("Subscription error:", error);
-                }
-            })();
-        }
-        const stopFunc = () => {
-            onchainStopFunc?.();
-            indexerStopFunc?.();
-        };
-        return stopFunc;
-    }
-    async handleBatchStartedEvent(event, intentId, forfeitPubKey, forfeitOutputScript) {
-        const utf8IntentId = new TextEncoder().encode(intentId);
-        const intentIdHash = sha256(utf8IntentId);
-        const intentIdHashStr = hex.encode(intentIdHash);
-        let skip = true;
-        // check if our intent ID hash matches any in the event
-        for (const idHash of event.intentIdHashes) {
-            if (idHash === intentIdHashStr) {
-                if (!this.arkProvider) {
-                    throw new Error("Ark provider not configured");
-                }
-                await this.arkProvider.confirmRegistration(intentId);
-                skip = false;
-            }
-        }
-        if (skip) {
-            return { skip };
-        }
-        const sweepTapscript = CSVMultisigTapscript.encode({
-            timelock: {
-                value: event.batchExpiry,
-                type: event.batchExpiry >= 512n ? "seconds" : "blocks",
-            },
-            pubkeys: [forfeitPubKey],
-        }).script;
-        const sweepTapTreeRoot = tapLeafHash(sweepTapscript);
-        return {
-            roundId: event.id,
-            sweepTapTreeRoot,
-            forfeitOutputScript,
-            skip: false,
-        };
-    }
-    // validates the vtxo tree, creates a signing session and generates the musig2 nonces
-    async handleSettlementSigningEvent(event, sweepTapTreeRoot, session, vtxoGraph) {
-        // validate the unsigned vtxo tree
-        const commitmentTx = Transaction.fromPSBT(base64.decode(event.unsignedCommitmentTx));
-        validateVtxoTxGraph(vtxoGraph, commitmentTx, sweepTapTreeRoot);
-        // TODO check if our registered outputs are in the vtxo tree
-        const sharedOutput = commitmentTx.getOutput(0);
-        if (!sharedOutput?.amount) {
-            throw new Error("Shared output not found");
+        finally {
+            // close the stream
+            abortController.abort();
         }
-        session.init(vtxoGraph, sweepTapTreeRoot, sharedOutput.amount);
-        const pubkey = hex.encode(await session.getPublicKey());
-        const nonces = await session.getNonces();
-        await this.arkProvider.submitTreeNonces(event.id, pubkey, nonces);
-    }
-    async handleSettlementTreeNoncesEvent(event, session) {
-        const { hasAllNonces } = await session.aggregatedNonces(event.txid, event.nonces);
-        // wait to receive and aggregate all nonces before sending signatures
-        if (!hasAllNonces)
-            return false;
-        const signatures = await session.sign();
-        const pubkey = hex.encode(await session.getPublicKey());
-        await this.arkProvider.submitTreeSignatures(event.id, pubkey, signatures);
-        return true;
     }
     async handleSettlementFinalizationEvent(event, inputs, forfeitOutputScript, connectorsGraph) {
         // the signed forfeits transactions to submit
@@ -922,9 +810,98 @@ export class Wallet {
                 : undefined);
         }
     }
+    /**
+     * @implements Batch.Handler interface.
+     * @param intentId - The intent ID.
+     * @param inputs - The inputs of the intent.
+     * @param session - The musig2 signing session, if not provided, the signing will be skipped.
+     */
+    createBatchHandler(intentId, inputs, session) {
+        let sweepTapTreeRoot;
+        return {
+            onBatchStarted: async (event) => {
+                const utf8IntentId = new TextEncoder().encode(intentId);
+                const intentIdHash = sha256(utf8IntentId);
+                const intentIdHashStr = hex.encode(intentIdHash);
+                let skip = true;
+                // check if our intent ID hash matches any in the event
+                for (const idHash of event.intentIdHashes) {
+                    if (idHash === intentIdHashStr) {
+                        if (!this.arkProvider) {
+                            throw new Error("Ark provider not configured");
+                        }
+                        await this.arkProvider.confirmRegistration(intentId);
+                        skip = false;
+                    }
+                }
+                if (skip) {
+                    return { skip };
+                }
+                const sweepTapscript = CSVMultisigTapscript.encode({
+                    timelock: {
+                        value: event.batchExpiry,
+                        type: event.batchExpiry >= 512n ? "seconds" : "blocks",
+                    },
+                    pubkeys: [this.forfeitPubkey],
+                }).script;
+                sweepTapTreeRoot = tapLeafHash(sweepTapscript);
+                return { skip: false };
+            },
+            onTreeSigningStarted: async (event, vtxoTree) => {
+                if (!session) {
+                    return { skip: true };
+                }
+                if (!sweepTapTreeRoot) {
+                    throw new Error("Sweep tap tree root not set");
+                }
+                const xOnlyPublicKeys = event.cosignersPublicKeys.map((k) => k.slice(2));
+                const signerPublicKey = await session.getPublicKey();
+                const xonlySignerPublicKey = signerPublicKey.subarray(1);
+                if (!xOnlyPublicKeys.includes(hex.encode(xonlySignerPublicKey))) {
+                    // not a cosigner, skip the signing
+                    return { skip: true };
+                }
+                // validate the unsigned vtxo tree
+                const commitmentTx = Transaction.fromPSBT(base64.decode(event.unsignedCommitmentTx));
+                validateVtxoTxGraph(vtxoTree, commitmentTx, sweepTapTreeRoot);
+                // TODO check if our registered outputs are in the vtxo tree
+                const sharedOutput = commitmentTx.getOutput(0);
+                if (!sharedOutput?.amount) {
+                    throw new Error("Shared output not found");
+                }
+                await session.init(vtxoTree, sweepTapTreeRoot, sharedOutput.amount);
+                const pubkey = hex.encode(await session.getPublicKey());
+                const nonces = await session.getNonces();
+                await this.arkProvider.submitTreeNonces(event.id, pubkey, nonces);
+                return { skip: false };
+            },
+            onTreeNonces: async (event) => {
+                if (!session) {
+                    return { fullySigned: true }; // Signing complete (no signing needed)
+                }
+                const { hasAllNonces } = await session.aggregatedNonces(event.txid, event.nonces);
+                // wait to receive and aggregate all nonces before sending signatures
+                if (!hasAllNonces)
+                    return { fullySigned: false };
+                const signatures = await session.sign();
+                const pubkey = hex.encode(await session.getPublicKey());
+                await this.arkProvider.submitTreeSignatures(event.id, pubkey, signatures);
+                return { fullySigned: true };
+            },
+            onBatchFinalization: async (event, _, connectorTree) => {
+                if (!this.forfeitOutputScript) {
+                    throw new Error("Forfeit output script not set");
+                }
+                if (connectorTree) {
+                    validateConnectorsTxGraph(event.commitmentTx, connectorTree);
+                }
+                await this.handleSettlementFinalizationEvent(event, inputs, this.forfeitOutputScript, connectorTree);
+            },
+        };
+    }
     async safeRegisterIntent(intent) {
         try {
-            return this.arkProvider.registerIntent(intent);
+            return await this.arkProvider.registerIntent(intent);
         }
         catch (error) {
             // catch the "already registered by another intent" error
@@ -952,12 +929,11 @@ export class Wallet {
             expire_at: 0,
             cosigners_public_keys: cosignerPubKeys,
         };
-        const encodedMessage = JSON.stringify(message, null, 0);
-        const proof = Intent.create(encodedMessage, inputs, outputs);
+        const proof = Intent.create(message, inputs, outputs);
         const signedProof = await this.identity.sign(proof);
         return {
             proof: base64.encode(signedProof.toPSBT()),
-            message: encodedMessage,
+            message,
         };
     }
     async makeDeleteIntentSignature(coins) {
@@ -966,19 +942,78 @@ export class Wallet {
             type: "delete",
             expire_at: 0,
         };
-        const encodedMessage = JSON.stringify(message, null, 0);
-        const proof = Intent.create(encodedMessage, inputs, []);
+        const proof = Intent.create(message, inputs, []);
         const signedProof = await this.identity.sign(proof);
         return {
             proof: base64.encode(signedProof.toPSBT()),
-            message: encodedMessage,
+            message,
         };
     }
+    async makeGetPendingTxIntentSignature(vtxos) {
+        const inputs = this.prepareIntentProofInputs(vtxos);
+        const message = {
+            type: "get-pending-tx",
+            expire_at: 0,
+        };
+        const proof = Intent.create(message, inputs, []);
+        const signedProof = await this.identity.sign(proof);
+        return {
+            proof: base64.encode(signedProof.toPSBT()),
+            message,
+        };
+    }
+    /**
+     * Finalizes pending transactions by retrieving them from the server and finalizing each one.
+     * @param vtxos - Optional list of VTXOs to use instead of retrieving them from the server
+     * @returns Array of transaction IDs that were finalized
+     */
+    async finalizePendingTxs(vtxos) {
+        const MAX_INPUTS_PER_INTENT = 20;
+        if (!vtxos || vtxos.length === 0) {
+            // get non-swept VTXOs, rely on the indexer only in case DB doesn't have the right state
+            const scripts = [hex.encode(this.offchainTapscript.pkScript)];
+            let { vtxos: fetchedVtxos } = await this.indexerProvider.getVtxos({
+                scripts,
+            });
+            fetchedVtxos = fetchedVtxos.filter((vtxo) => vtxo.virtualStatus.state !== "swept" &&
+                vtxo.virtualStatus.state !== "settled");
+            if (fetchedVtxos.length === 0) {
+                return { finalized: [], pending: [] };
+            }
+            vtxos = fetchedVtxos.map((v) => extendVirtualCoin(this, v));
+        }
+        const finalized = [];
+        const pending = [];
+        for (let i = 0; i < vtxos.length; i += MAX_INPUTS_PER_INTENT) {
+            const batch = vtxos.slice(i, i + MAX_INPUTS_PER_INTENT);
+            const intent = await this.makeGetPendingTxIntentSignature(batch);
+            const pendingTxs = await this.arkProvider.getPendingTxs(intent);
+            // finalize each transaction by signing the checkpoints
+            for (const pendingTx of pendingTxs) {
+                pending.push(pendingTx.arkTxid);
+                try {
+                    // sign the checkpoints
+                    const finalCheckpoints = await Promise.all(pendingTx.signedCheckpointTxs.map(async (c) => {
+                        const tx = Transaction.fromPSBT(base64.decode(c));
+                        const signedCheckpoint = await this.identity.sign(tx);
+                        return base64.encode(signedCheckpoint.toPSBT());
+                    }));
+                    await this.arkProvider.finalizeTx(pendingTx.arkTxid, finalCheckpoints);
+                    finalized.push(pendingTx.arkTxid);
+                }
+                catch (error) {
+                    console.error(`Failed to finalize transaction ${pendingTx.arkTxid}:`, error);
+                    // continue with other transactions even if one fails
+                }
+            }
+        }
+        return { finalized, pending };
+    }
     prepareIntentProofInputs(coins) {
         const inputs = [];
         for (const input of coins) {
             const vtxoScript = VtxoScript.decode(input.tapTree);
-            const sequence = getSequence(input);
+            const sequence = getSequence(input.intentTapLeafScript);
             const unknown = [VtxoTaprootTree.encode(input.tapTree)];
             if (input.extraWitness) {
                 unknown.push(ConditionWitness.encode(input.extraWitness));
@@ -999,15 +1034,21 @@ export class Wallet {
     }
 }
 Wallet.MIN_FEE_RATE = 1; // sats/vbyte
-function getSequence(coin) {
+export function getSequence(tapLeafScript) {
     let sequence = undefined;
     try {
-        const scriptWithLeafVersion = coin.intentTapLeafScript[1];
+        const scriptWithLeafVersion = tapLeafScript[1];
         const script = scriptWithLeafVersion.subarray(0, scriptWithLeafVersion.length - 1);
-        const params = CSVMultisigTapscript.decode(script).params;
-        sequence = bip68.encode(params.timelock.type === "blocks"
-            ? { blocks: Number(params.timelock.value) }
-            : { seconds: Number(params.timelock.value) });
+        try {
+            const params = CSVMultisigTapscript.decode(script).params;
+            sequence = bip68.encode(params.timelock.type === "blocks"
+                ? { blocks: Number(params.timelock.value) }
+                : { seconds: Number(params.timelock.value) });
+        }
+        catch {
+            const params = CLTVMultisigTapscript.decode(script).params;
+            sequence = Number(params.absoluteTimelock);
+        }
     }
     catch { }
     return sequence;