@arkade-os/sdk 0.3.8 → 0.3.10

package/dist/cjs/wallet/wallet.js

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Wallet = void 0;
+exports.Wallet = exports.ReadonlyWallet = void 0;
+exports.getSequence = getSequence;
 exports.waitForIncomingFunds = waitForIncomingFunds;
 const base_1 = require("@scure/base");
 const bip68 = __importStar(require("bip68"));
@@ -56,74 +57,40 @@ const vtxo_manager_1 = require("./vtxo-manager");
 const arknote_1 = require("../arknote");
 const intent_1 = require("../intent");
 const indexer_1 = require("../providers/indexer");
-const txTree_1 = require("../tree/txTree");
 const unknownFields_1 = require("../utils/unknownFields");
 const inMemory_1 = require("../storage/inMemory");
 const walletRepository_1 = require("../repositories/walletRepository");
 const contractRepository_1 = require("../repositories/contractRepository");
 const utils_1 = require("./utils");
 const errors_1 = require("../providers/errors");
+const batch_1 = require("./batch");
 /**
- * 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.
  */
-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");
+}
+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,
-            ...vtxo_manager_1.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 ||
             (() => {
@@ -187,25 +154,32 @@ 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 = base_1.hex.decode(info.checkpointTapscript);
-            serverUnrollScript = tapscript_1.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 = base_1.hex.decode(info.forfeitPubkey).slice(1);
-        const forfeitAddress = (0, btc_signer_1.Address)(network).decode(info.forfeitAddress);
-        const forfeitOutputScript = btc_signer_1.OutScript.encode(forfeitAddress);
         // Set up storage and repositories
         const storage = config.storage || new inMemory_1.InMemoryStorageAdapter();
         const walletRepository = new walletRepository_1.WalletRepositoryImpl(storage);
         const contractRepository = new contractRepository_1.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);
@@ -280,7 +254,7 @@ class Wallet {
         let vtxos = allVtxos.filter(_1.isSpendable);
         // all recoverable vtxos are spendable by definition
         if (!filter.withRecoverable) {
-            vtxos = vtxos.filter((vtxo) => !(0, _1.isRecoverable)(vtxo));
+            vtxos = vtxos.filter((vtxo) => !(0, _1.isRecoverable)(vtxo) && !(0, _1.isExpired)(vtxo));
         }
         if (filter.withUnrolled) {
             const spentVtxos = allVtxos.filter((vtxo) => !(0, _1.isSpendable)(vtxo));
@@ -289,9 +263,6 @@ class Wallet {
         return vtxos;
     }
     async getTransactionHistory() {
-        if (!this.indexerProvider) {
-            return [];
-        }
         const response = await this.indexerProvider.getVtxos({
             scripts: [base_1.hex.encode(this.offchainTapscript.pkScript)],
         });
@@ -395,6 +366,179 @@ 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([
+                base_1.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) => (0, utils_1.extendVirtualCoin)(this, vtxo)),
+                                spentVtxos: update.spentVtxos.map((vtxo) => (0, utils_1.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 = [base_1.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);
+    }
+}
+exports.ReadonlyWallet = ReadonlyWallet;
+/**
+ * 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
+ * });
+ * ```
+ */
+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,
+            ...vtxo_manager_1.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 = base_1.hex.decode(setup.info.checkpointTapscript);
+            serverUnrollScript = tapscript_1.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 = base_1.hex.decode(setup.info.forfeitPubkey).slice(1);
+        const forfeitAddress = (0, btc_signer_1.Address)(setup.network).decode(setup.info.forfeitAddress);
+        const forfeitOutputScript = btc_signer_1.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");
@@ -406,7 +550,23 @@ class Wallet {
         const virtualCoins = await this.getVirtualCoins({
             withRecoverable: false,
         });
-        const selected = selectVirtualCoins(virtualCoins, params.amount);
+        let selected;
+        if (params.selectedVtxos) {
+            const selectedVtxoSum = params.selectedVtxos
+                .map((v) => v.value)
+                .reduce((a, b) => a + b, 0);
+            if (selectedVtxoSum < params.amount) {
+                throw new Error("Selected VTXOs do not cover specified amount");
+            }
+            const changeAmount = selectedVtxoSum - params.amount;
+            selected = {
+                inputs: params.selectedVtxos,
+                changeAmount: BigInt(changeAmount),
+            };
+        }
+        else {
+            selected = selectVirtualCoins(virtualCoins, params.amount);
+        }
         const selectedLeaf = this.offchainTapscript.forfeit();
         if (!selectedLeaf) {
             throw new Error("Selected leaf not found");
@@ -481,7 +641,7 @@ 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(),
@@ -591,285 +751,31 @@ 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 ark_1.SettlementEventType.BatchFailed:
-                        throw new Error(event.reason);
-                    case ark_1.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 = ark_1.SettlementEventType.TreeNonces;
-                            }
-                        }
-                        break;
-                    case ark_1.SettlementEventType.TreeTx:
-                        if (step !== ark_1.SettlementEventType.BatchStarted &&
-                            step !== ark_1.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 ark_1.SettlementEventType.TreeSignature:
-                        if (step !== ark_1.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 = base_1.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 ark_1.SettlementEventType.TreeSigningStarted:
-                        if (step !== ark_1.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_1.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 ark_1.SettlementEventType.TreeNonces:
-                        if (step !== ark_1.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 ark_1.SettlementEventType.BatchFinalization:
-                        if (step !== ark_1.SettlementEventType.TreeNonces) {
-                            continue;
-                        }
-                        if (!this.forfeitOutputScript) {
-                            throw new Error("Forfeit output script not set");
-                        }
-                        if (connectorsChunks.length > 0) {
-                            connectorsGraph = txTree_1.TxTree.create(connectorsChunks);
-                            (0, validation_1.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 ark_1.SettlementEventType.BatchFinalized:
-                        if (step !== ark_1.SettlementEventType.BatchFinalization) {
-                            continue;
-                        }
-                        if (event.id === batchId) {
-                            abortController.abort();
-                            return event.commitmentTxid;
-                        }
-                }
-            }
+            const stream = this.arkProvider.getEventStream(abortController.signal, topics);
+            return await batch_1.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([
-                base_1.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) => (0, utils_1.extendVirtualCoin)(this, vtxo)),
-                                spentVtxos: update.spentVtxos.map((vtxo) => (0, utils_1.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 = (0, utils_js_1.sha256)(utf8IntentId);
-        const intentIdHashStr = base_1.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 = tapscript_1.CSVMultisigTapscript.encode({
-            timelock: {
-                value: event.batchExpiry,
-                type: event.batchExpiry >= 512n ? "seconds" : "blocks",
-            },
-            pubkeys: [forfeitPubKey],
-        }).script;
-        const sweepTapTreeRoot = (0, payment_js_1.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 = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(event.unsignedCommitmentTx));
-        (0, validation_1.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 = base_1.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 = base_1.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
@@ -959,9 +865,98 @@ 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 = (0, utils_js_1.sha256)(utf8IntentId);
+                const intentIdHashStr = base_1.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 = tapscript_1.CSVMultisigTapscript.encode({
+                    timelock: {
+                        value: event.batchExpiry,
+                        type: event.batchExpiry >= 512n ? "seconds" : "blocks",
+                    },
+                    pubkeys: [this.forfeitPubkey],
+                }).script;
+                sweepTapTreeRoot = (0, payment_js_1.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(base_1.hex.encode(xonlySignerPublicKey))) {
+                    // not a cosigner, skip the signing
+                    return { skip: true };
+                }
+                // validate the unsigned vtxo tree
+                const commitmentTx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(event.unsignedCommitmentTx));
+                (0, validation_1.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 = base_1.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 = base_1.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) {
+                    (0, validation_1.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
@@ -989,12 +984,11 @@ class Wallet {
             expire_at: 0,
             cosigners_public_keys: cosignerPubKeys,
         };
-        const encodedMessage = JSON.stringify(message, null, 0);
-        const proof = intent_1.Intent.create(encodedMessage, inputs, outputs);
+        const proof = intent_1.Intent.create(message, inputs, outputs);
         const signedProof = await this.identity.sign(proof);
         return {
             proof: base_1.base64.encode(signedProof.toPSBT()),
-            message: encodedMessage,
+            message,
         };
     }
     async makeDeleteIntentSignature(coins) {
@@ -1003,12 +997,11 @@ class Wallet {
             type: "delete",
             expire_at: 0,
         };
-        const encodedMessage = JSON.stringify(message, null, 0);
-        const proof = intent_1.Intent.create(encodedMessage, inputs, []);
+        const proof = intent_1.Intent.create(message, inputs, []);
         const signedProof = await this.identity.sign(proof);
         return {
             proof: base_1.base64.encode(signedProof.toPSBT()),
-            message: encodedMessage,
+            message,
         };
     }
     async makeGetPendingTxIntentSignature(vtxos) {
@@ -1017,12 +1010,11 @@ class Wallet {
             type: "get-pending-tx",
             expire_at: 0,
         };
-        const encodedMessage = JSON.stringify(message, null, 0);
-        const proof = intent_1.Intent.create(encodedMessage, inputs, []);
+        const proof = intent_1.Intent.create(message, inputs, []);
         const signedProof = await this.identity.sign(proof);
         return {
             proof: base_1.base64.encode(signedProof.toPSBT()),
-            message: encodedMessage,
+            message,
         };
     }
     /**
@@ -1076,7 +1068,7 @@ class Wallet {
         const inputs = [];
         for (const input of coins) {
             const vtxoScript = base_2.VtxoScript.decode(input.tapTree);
-            const sequence = getSequence(input);
+            const sequence = getSequence(input.intentTapLeafScript);
             const unknown = [unknownFields_1.VtxoTaprootTree.encode(input.tapTree)];
             if (input.extraWitness) {
                 unknown.push(unknownFields_1.ConditionWitness.encode(input.extraWitness));
@@ -1098,15 +1090,21 @@ class Wallet {
 }
 exports.Wallet = Wallet;
 Wallet.MIN_FEE_RATE = 1; // sats/vbyte
-function getSequence(coin) {
+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 = tapscript_1.CSVMultisigTapscript.decode(script).params;
-        sequence = bip68.encode(params.timelock.type === "blocks"
-            ? { blocks: Number(params.timelock.value) }
-            : { seconds: Number(params.timelock.value) });
+        try {
+            const params = tapscript_1.CSVMultisigTapscript.decode(script).params;
+            sequence = bip68.encode(params.timelock.type === "blocks"
+                ? { blocks: Number(params.timelock.value) }
+                : { seconds: Number(params.timelock.value) });
+        }
+        catch {
+            const params = tapscript_1.CLTVMultisigTapscript.decode(script).params;
+            sequence = Number(params.absoluteTimelock);
+        }
     }
     catch { }
     return sequence;