@arkade-os/sdk 0.1.4 → 0.2.1

package/dist/esm/wallet/serviceWorker/worker.js

@@ -1,14 +1,19 @@
 /// <reference lib="webworker" />
-import { InMemoryKey } from '../../identity/inMemoryKey.js';
+import { SingleKey } from '../../identity/singleKey.js';
+import { isSpendable, isSubdust } from '../index.js';
 import { Wallet } from '../wallet.js';
 import { Request } from './request.js';
 import { Response } from './response.js';
 import { RestArkProvider } from '../../providers/ark.js';
-import { DefaultVtxo } from '../../script/default.js';
 import { IndexedDBVtxoRepository } from './db/vtxo/idb.js';
 import { vtxosToTxs } from '../../utils/transactionHistory.js';
-// Worker is a class letting to interact with ServiceWorkerWallet from the client
-// it aims to be run in a service worker context
+import { RestIndexerProvider } from '../../providers/indexer.js';
+import { base64, hex } from "@scure/base";
+import { Transaction } from "@scure/btc-signer";
+/**
+ * Worker is a class letting to interact with ServiceWorkerWallet from the client
+ * it aims to be run in a service worker context
+ */
 export class Worker {
     constructor(vtxoRepository = new IndexedDBVtxoRepository(), messageCallback = () => { }) {
         this.vtxoRepository = vtxoRepository;
@@ -36,41 +41,48 @@ export class Worker {
         await this.vtxoRepository.close();
         this.wallet = undefined;
         this.arkProvider = undefined;
+        this.indexerProvider = undefined;
         this.vtxoSubscription = undefined;
     }
     async onWalletInitialized() {
         if (!this.wallet ||
             !this.arkProvider ||
+            !this.indexerProvider ||
             !this.wallet.offchainTapscript ||
             !this.wallet.boardingTapscript) {
             return;
         }
         // subscribe to address updates
-        const addressInfo = await this.wallet.getAddressInfo();
-        if (!addressInfo.offchain) {
-            return;
-        }
         await this.vtxoRepository.open();
-        // set the initial vtxos state
-        const { spendableVtxos, spentVtxos } = await this.arkProvider.getVirtualCoins(addressInfo.offchain.address);
         const encodedOffchainTapscript = this.wallet.offchainTapscript.encode();
         const forfeit = this.wallet.offchainTapscript.forfeit();
-        const vtxos = [...spendableVtxos, ...spentVtxos].map((vtxo) => ({
+        const exit = this.wallet.offchainTapscript.exit();
+        const script = hex.encode(this.wallet.offchainTapscript.pkScript);
+        // set the initial vtxos state
+        const response = await this.indexerProvider.getVtxos({
+            scripts: [script],
+        });
+        const vtxos = response.vtxos.map((vtxo) => ({
             ...vtxo,
-            tapLeafScript: forfeit,
-            scripts: encodedOffchainTapscript,
+            forfeitTapLeafScript: forfeit,
+            intentTapLeafScript: exit,
+            tapTree: encodedOffchainTapscript,
         }));
         await this.vtxoRepository.addOrUpdate(vtxos);
-        this.processVtxoSubscription(addressInfo.offchain);
+        this.processVtxoSubscription({
+            script,
+            vtxoScript: this.wallet.offchainTapscript,
+        });
     }
-    async processVtxoSubscription({ address, scripts, }) {
+    async processVtxoSubscription({ script, vtxoScript, }) {
         try {
-            const addressScripts = [...scripts.exit, ...scripts.forfeit];
-            const vtxoScript = DefaultVtxo.Script.decode(addressScripts);
-            const tapLeafScript = vtxoScript.findLeaf(scripts.forfeit[0]);
+            const forfeitTapLeafScript = vtxoScript.forfeit();
+            const intentTapLeafScript = vtxoScript.exit();
             const abortController = new AbortController();
-            const subscription = this.arkProvider.subscribeForAddress(address, abortController.signal);
+            const subscriptionId = await this.indexerProvider.subscribeForScripts([script]);
+            const subscription = this.indexerProvider.getSubscription(subscriptionId, abortController.signal);
             this.vtxoSubscription = abortController;
+            const tapTree = vtxoScript.encode();
             for await (const update of subscription) {
                 const vtxos = [...update.newVtxos, ...update.spentVtxos];
                 if (vtxos.length === 0) {
@@ -78,8 +90,9 @@ export class Worker {
                 }
                 const extendedVtxos = vtxos.map((vtxo) => ({
                     ...vtxo,
-                    tapLeafScript,
-                    scripts: addressScripts,
+                    forfeitTapLeafScript,
+                    intentTapLeafScript,
+                    tapTree,
                 }));
                 await this.vtxoRepository.addOrUpdate(extendedVtxos);
             }
@@ -103,9 +116,9 @@ export class Worker {
         }
         try {
             this.arkProvider = new RestArkProvider(message.arkServerUrl);
+            this.indexerProvider = new RestIndexerProvider(message.arkServerUrl);
             this.wallet = await Wallet.create({
-                network: message.network,
-                identity: InMemoryKey.fromHex(message.privateKey),
+                identity: SingleKey.fromHex(message.privateKey),
                 arkServerUrl: message.arkServerUrl,
                 arkServerPublicKey: message.arkServerPublicKey,
             });
@@ -159,7 +172,7 @@ export class Worker {
             return;
         }
         try {
-            const txid = await this.wallet.sendBitcoin(message.params, message.zeroFee);
+            const txid = await this.wallet.sendBitcoin(message.params);
             event.source?.postMessage(Response.sendBitcoinSuccess(message.id, txid));
         }
         catch (error) {
@@ -183,8 +196,8 @@ export class Worker {
             return;
         }
         try {
-            const addresses = await this.wallet.getAddress();
-            event.source?.postMessage(Response.addresses(message.id, addresses));
+            const address = await this.wallet.getAddress();
+            event.source?.postMessage(Response.address(message.id, address));
         }
         catch (error) {
             console.error("Error getting address:", error);
@@ -194,11 +207,11 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, errorMessage));
         }
     }
-    async handleGetAddressInfo(event) {
+    async handleGetBoardingAddress(event) {
         const message = event.data;
-        if (!Request.isGetAddressInfo(message)) {
-            console.error("Invalid GET_ADDRESS_INFO message format", message);
-            event.source?.postMessage(Response.error(message.id, "Invalid GET_ADDRESS_INFO message format"));
+        if (!Request.isGetBoardingAddress(message)) {
+            console.error("Invalid GET_BOARDING_ADDRESS message format", message);
+            event.source?.postMessage(Response.error(message.id, "Invalid GET_BOARDING_ADDRESS message format"));
             return;
         }
         if (!this.wallet) {
@@ -207,11 +220,11 @@ export class Worker {
             return;
         }
         try {
-            const addressInfo = await this.wallet.getAddressInfo();
-            event.source?.postMessage(Response.addressInfo(message.id, addressInfo));
+            const address = await this.wallet.getBoardingAddress();
+            event.source?.postMessage(Response.boardingAddress(message.id, address));
         }
         catch (error) {
-            console.error("Error getting address info:", error);
+            console.error("Error getting boarding address:", error);
             const errorMessage = error instanceof Error
                 ? error.message
                 : "Unknown error occurred";
@@ -231,40 +244,52 @@ export class Worker {
             return;
         }
         try {
-            const coins = await this.wallet.getCoins();
-            const onchainConfirmed = coins
-                .filter((coin) => coin.status.confirmed)
-                .reduce((sum, coin) => sum + coin.value, 0);
-            const onchainUnconfirmed = coins
-                .filter((coin) => !coin.status.confirmed)
-                .reduce((sum, coin) => sum + coin.value, 0);
-            const onchainTotal = onchainConfirmed + onchainUnconfirmed;
-            const spendableVtxos = await this.vtxoRepository.getSpendableVtxos();
-            const offchainSettledBalance = spendableVtxos.reduce((sum, vtxo) => vtxo.virtualStatus.state === "settled"
-                ? sum + vtxo.value
-                : sum, 0);
-            const offchainPendingBalance = spendableVtxos.reduce((sum, vtxo) => vtxo.virtualStatus.state === "pending"
-                ? sum + vtxo.value
-                : sum, 0);
-            const offchainSweptBalance = spendableVtxos.reduce((sum, vtxo) => vtxo.virtualStatus.state === "swept"
-                ? sum + vtxo.value
-                : sum, 0);
-            const offchainTotal = offchainSettledBalance +
-                offchainPendingBalance +
-                offchainSweptBalance;
+            const [boardingUtxos, spendableVtxos, sweptVtxos] = await Promise.all([
+                this.wallet.getBoardingUtxos(),
+                this.vtxoRepository.getSpendableVtxos(),
+                this.vtxoRepository.getSweptVtxos(),
+            ]);
+            // boarding
+            let confirmed = 0;
+            let unconfirmed = 0;
+            for (const utxo of boardingUtxos) {
+                if (utxo.status.confirmed) {
+                    confirmed += utxo.value;
+                }
+                else {
+                    unconfirmed += utxo.value;
+                }
+            }
+            // offchain
+            let settled = 0;
+            let preconfirmed = 0;
+            let recoverable = 0;
+            for (const vtxo of spendableVtxos) {
+                if (vtxo.virtualStatus.state === "settled") {
+                    settled += vtxo.value;
+                }
+                else if (vtxo.virtualStatus.state === "preconfirmed") {
+                    preconfirmed += vtxo.value;
+                }
+            }
+            for (const vtxo of sweptVtxos) {
+                if (isSpendable(vtxo)) {
+                    recoverable += vtxo.value;
+                }
+            }
+            const totalBoarding = confirmed + unconfirmed;
+            const totalOffchain = settled + preconfirmed + recoverable;
             event.source?.postMessage(Response.balance(message.id, {
-                onchain: {
-                    confirmed: onchainConfirmed,
-                    unconfirmed: onchainUnconfirmed,
-                    total: onchainTotal,
+                boarding: {
+                    confirmed,
+                    unconfirmed,
+                    total: totalBoarding,
                 },
-                offchain: {
-                    swept: offchainSweptBalance,
-                    settled: offchainSettledBalance,
-                    pending: offchainPendingBalance,
-                    total: offchainTotal,
-                },
-                total: onchainTotal + offchainTotal,
+                settled,
+                preconfirmed,
+                available: settled + preconfirmed,
+                recoverable,
+                total: totalBoarding + totalOffchain,
             }));
         }
         catch (error) {
@@ -275,30 +300,6 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, errorMessage));
         }
     }
-    async handleGetCoins(event) {
-        const message = event.data;
-        if (!Request.isGetCoins(message)) {
-            console.error("Invalid GET_COINS message format", message);
-            event.source?.postMessage(Response.error(message.id, "Invalid GET_COINS message format"));
-            return;
-        }
-        if (!this.wallet) {
-            console.error("Wallet not initialized");
-            event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
-            return;
-        }
-        try {
-            const coins = await this.wallet.getCoins();
-            event.source?.postMessage(Response.coins(message.id, coins));
-        }
-        catch (error) {
-            console.error("Error getting coins:", error);
-            const errorMessage = error instanceof Error
-                ? error.message
-                : "Unknown error occurred";
-            event.source?.postMessage(Response.error(message.id, errorMessage));
-        }
-    }
     async handleGetVtxos(event) {
         const message = event.data;
         if (!Request.isGetVtxos(message)) {
@@ -312,7 +313,18 @@ export class Worker {
             return;
         }
         try {
-            const vtxos = await this.vtxoRepository.getSpendableVtxos();
+            let vtxos = await this.vtxoRepository.getSpendableVtxos();
+            if (!message.filter?.withRecoverable) {
+                if (!this.wallet)
+                    throw new Error("Wallet not initialized");
+                // exclude subdust is we don't want recoverable
+                vtxos = vtxos.filter((v) => !isSubdust(v, this.wallet.dustAmount));
+            }
+            if (message.filter?.withRecoverable) {
+                // get also swept and spendable vtxos
+                const sweptVtxos = await this.vtxoRepository.getSweptVtxos();
+                vtxos.push(...sweptVtxos.filter(isSpendable));
+            }
             event.source?.postMessage(Response.vtxos(message.id, vtxos));
         }
         catch (error) {
@@ -360,7 +372,7 @@ export class Worker {
             return;
         }
         try {
-            const { boardingTxs, roundsToIgnore } = await this.wallet.getBoardingTxs();
+            const { boardingTxs, commitmentsToIgnore: roundsToIgnore } = await this.wallet.getBoardingTxs();
             const { spendable, spent } = await this.vtxoRepository.getAllVtxos();
             // convert VTXOs to offchain transactions
             const offchainTxs = vtxosToTxs(spendable, spent, roundsToIgnore);
@@ -394,11 +406,11 @@ export class Worker {
         }
         event.source?.postMessage(Response.walletStatus(message.id, this.wallet !== undefined));
     }
-    async handleExit(event) {
+    async handleSign(event) {
         const message = event.data;
-        if (!Request.isExit(message)) {
-            console.error("Invalid EXIT message format", message);
-            event.source?.postMessage(Response.error(message.id, "Invalid EXIT message format"));
+        if (!Request.isSign(message)) {
+            console.error("Invalid SIGN message format", message);
+            event.source?.postMessage(Response.error(message.id, "Invalid SIGN message format"));
             return;
         }
         if (!this.wallet) {
@@ -407,11 +419,15 @@ export class Worker {
             return;
         }
         try {
-            await this.wallet.exit(message.outpoints);
-            event.source?.postMessage(Response.exitSuccess(message.id));
+            const tx = Transaction.fromPSBT(base64.decode(message.tx), {
+                allowUnknown: true,
+                allowUnknownInputs: true,
+            });
+            const signedTx = await this.wallet.identity.sign(tx, message.inputIndexes);
+            event.source?.postMessage(Response.signSuccess(message.id, base64.encode(signedTx.toPSBT())));
         }
         catch (error) {
-            console.error("Error exiting:", error);
+            console.error("Error signing:", error);
             const errorMessage = error instanceof Error
                 ? error.message
                 : "Unknown error occurred";
@@ -443,18 +459,14 @@ export class Worker {
                 await this.handleGetAddress(event);
                 break;
             }
-            case "GET_ADDRESS_INFO": {
-                await this.handleGetAddressInfo(event);
+            case "GET_BOARDING_ADDRESS": {
+                await this.handleGetBoardingAddress(event);
                 break;
             }
             case "GET_BALANCE": {
                 await this.handleGetBalance(event);
                 break;
             }
-            case "GET_COINS": {
-                await this.handleGetCoins(event);
-                break;
-            }
             case "GET_VTXOS": {
                 await this.handleGetVtxos(event);
                 break;
@@ -471,14 +483,14 @@ export class Worker {
                 await this.handleGetStatus(event);
                 break;
             }
-            case "EXIT": {
-                await this.handleExit(event);
-                break;
-            }
             case "CLEAR": {
                 await this.handleClear(event);
                 break;
             }
+            case "SIGN": {
+                await this.handleSign(event);
+                break;
+            }
             default:
                 event.source?.postMessage(Response.error(message.id, "Unknown message type"));
         }

package/dist/esm/wallet/unroll.js

@@ -0,0 +1,267 @@
+import { SigHash, Transaction } from "@scure/btc-signer";
+import { ChainTxType } from '../providers/indexer.js';
+import { base64, hex } from "@scure/base";
+import { VtxoScript } from '../script/base.js';
+import { TaprootControlBlock, } from "@scure/btc-signer/psbt";
+import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
+import { Wallet } from './wallet.js';
+export var Unroll;
+(function (Unroll) {
+    let StepType;
+    (function (StepType) {
+        StepType[StepType["UNROLL"] = 0] = "UNROLL";
+        StepType[StepType["WAIT"] = 1] = "WAIT";
+        StepType[StepType["DONE"] = 2] = "DONE";
+    })(StepType = Unroll.StepType || (Unroll.StepType = {}));
+    /**
+     * Manages the unrolling process of a VTXO back to the Bitcoin blockchain.
+     *
+     * The Session class implements an async iterator that processes the unrolling steps:
+     * 1. **WAIT**: Waits for a transaction to be confirmed onchain (if it's in mempool)
+     * 2. **UNROLL**: Broadcasts the next transaction in the chain to the blockchain
+     * 3. **DONE**: Indicates the unrolling process is complete
+     *
+     * The unrolling process works by traversing the transaction chain from the root (most recent)
+     * to the leaf (oldest), broadcasting each transaction that isn't already onchain.
+     *
+     * @example
+     * ```typescript
+     * const session = await Unroll.Session.create(vtxoOutpoint, bumper, explorer, indexer);
+     *
+     * // iterate over the steps
+     * for await (const doneStep of session) {
+     *   switch (doneStep.type) {
+     *     case Unroll.StepType.WAIT:
+     *       console.log(`Transaction ${doneStep.txid} confirmed`);
+     *       break;
+     *     case Unroll.StepType.UNROLL:
+     *       console.log(`Broadcasting transaction ${doneStep.tx.id}`);
+     *       break;
+     *     case Unroll.StepType.DONE:
+     *       console.log(`Unrolling complete for VTXO ${doneStep.vtxoTxid}`);
+     *       break;
+     *   }
+     * }
+     * ```
+     **/
+    class Session {
+        constructor(toUnroll, bumper, explorer, indexer) {
+            this.toUnroll = toUnroll;
+            this.bumper = bumper;
+            this.explorer = explorer;
+            this.indexer = indexer;
+        }
+        static async create(toUnroll, bumper, explorer, indexer) {
+            const { chain } = await indexer.getVtxoChain(toUnroll);
+            return new Session({ ...toUnroll, chain }, bumper, explorer, indexer);
+        }
+        /**
+         * Get the next step to be executed
+         * @returns The next step to be executed + the function to execute it
+         */
+        async next() {
+            let nextTxToBroadcast;
+            const chain = this.toUnroll.chain;
+            // Iterate through the chain from the end (root) to the beginning (leaf)
+            for (let i = chain.length - 1; i >= 0; i--) {
+                const chainTx = chain[i];
+                // Skip commitment transactions as they are always onchain
+                if (chainTx.type === ChainTxType.COMMITMENT ||
+                    chainTx.type === ChainTxType.UNSPECIFIED) {
+                    continue;
+                }
+                try {
+                    // Check if the transaction is confirmed onchain
+                    const txInfo = await this.explorer.getTxStatus(chainTx.txid);
+                    // If found but not confirmed, it means the tx is in the mempool
+                    // An unilateral exit is running, we must wait for it to be confirmed
+                    if (!txInfo.confirmed) {
+                        return {
+                            type: StepType.WAIT,
+                            txid: chainTx.txid,
+                            do: doWait(this.explorer, chainTx.txid),
+                        };
+                    }
+                }
+                catch (e) {
+                    // If the tx is not found, it's offchain, let's break
+                    nextTxToBroadcast = chainTx;
+                    break;
+                }
+            }
+            if (!nextTxToBroadcast) {
+                return {
+                    type: StepType.DONE,
+                    vtxoTxid: this.toUnroll.txid,
+                    do: () => Promise.resolve(),
+                };
+            }
+            // Get the virtual transaction data
+            const virtualTxs = await this.indexer.getVirtualTxs([
+                nextTxToBroadcast.txid,
+            ]);
+            if (virtualTxs.txs.length === 0) {
+                throw new Error(`Tx ${nextTxToBroadcast.txid} not found`);
+            }
+            const tx = Transaction.fromPSBT(base64.decode(virtualTxs.txs[0]), {
+                allowUnknownInputs: true,
+            });
+            // finalize the tree transaction
+            if (nextTxToBroadcast.type === ChainTxType.TREE) {
+                const input = tx.getInput(0);
+                if (!input) {
+                    throw new Error("Input not found");
+                }
+                const tapKeySig = input.tapKeySig;
+                if (!tapKeySig) {
+                    throw new Error("Tap key sig not found");
+                }
+                tx.updateInput(0, {
+                    finalScriptWitness: [tapKeySig],
+                });
+            }
+            else {
+                // finalize ark transaction
+                tx.finalize();
+            }
+            return {
+                type: StepType.UNROLL,
+                tx,
+                do: doUnroll(this.bumper, this.explorer, tx),
+            };
+        }
+        /**
+         * Iterate over the steps to be executed and execute them
+         * @returns An async iterator over the executed steps
+         */
+        async *[Symbol.asyncIterator]() {
+            let lastStep;
+            do {
+                if (lastStep !== undefined) {
+                    // wait 1 second before trying the next step in order to give time to the
+                    // explorer to update the tx status
+                    await sleep(1000);
+                }
+                const step = await this.next();
+                await step.do();
+                yield step;
+                lastStep = step.type;
+            } while (lastStep !== StepType.DONE);
+        }
+    }
+    Unroll.Session = Session;
+    /**
+     * Complete the unroll of a VTXO by broadcasting the transaction that spends the CSV path.
+     * @param wallet the wallet owning the VTXO(s)
+     * @param vtxoTxids the txids of the VTXO(s) to complete unroll
+     * @param outputAddress the address to send the unrolled funds to
+     * @throws if the VTXO(s) are not fully unrolled, if the txids are not found, if the tx is not confirmed, if no exit path is found or not available
+     * @returns the txid of the transaction spending the unrolled funds
+     */
+    async function completeUnroll(wallet, vtxoTxids, outputAddress) {
+        const chainTip = await wallet.onchainProvider.getChainTip();
+        let vtxos = await wallet.getVtxos({ withUnrolled: true });
+        vtxos = vtxos.filter((vtxo) => vtxoTxids.includes(vtxo.txid));
+        if (vtxos.length === 0) {
+            throw new Error("No vtxos to complete unroll");
+        }
+        const inputs = [];
+        let totalAmount = 0n;
+        const txWeightEstimator = TxWeightEstimator.create();
+        for (const vtxo of vtxos) {
+            if (!vtxo.isUnrolled) {
+                throw new Error(`Vtxo ${vtxo.txid}:${vtxo.vout} is not fully unrolled, use unroll first`);
+            }
+            const txStatus = await wallet.onchainProvider.getTxStatus(vtxo.txid);
+            if (!txStatus.confirmed) {
+                throw new Error(`tx ${vtxo.txid} is not confirmed`);
+            }
+            const exit = availableExitPath({ height: txStatus.blockHeight, time: txStatus.blockTime }, chainTip, vtxo);
+            if (!exit) {
+                throw new Error(`no available exit path found for vtxo ${vtxo.txid}:${vtxo.vout}`);
+            }
+            const spendingLeaf = VtxoScript.decode(vtxo.tapTree).findLeaf(hex.encode(exit.script));
+            if (!spendingLeaf) {
+                throw new Error(`spending leaf not found for vtxo ${vtxo.txid}:${vtxo.vout}`);
+            }
+            totalAmount += BigInt(vtxo.value);
+            inputs.push({
+                txid: vtxo.txid,
+                index: vtxo.vout,
+                tapLeafScript: [spendingLeaf],
+                sequence: 0xffffffff - 1,
+                witnessUtxo: {
+                    amount: BigInt(vtxo.value),
+                    script: VtxoScript.decode(vtxo.tapTree).pkScript,
+                },
+                sighashType: SigHash.DEFAULT,
+            });
+            txWeightEstimator.addTapscriptInput(64, spendingLeaf[1].length, TaprootControlBlock.encode(spendingLeaf[0]).length);
+        }
+        const tx = new Transaction({ allowUnknownInputs: true, version: 2 });
+        for (const input of inputs) {
+            tx.addInput(input);
+        }
+        txWeightEstimator.addP2TROutput();
+        let feeRate = await wallet.onchainProvider.getFeeRate();
+        if (!feeRate || feeRate < Wallet.MIN_FEE_RATE) {
+            feeRate = Wallet.MIN_FEE_RATE;
+        }
+        const feeAmount = txWeightEstimator.vsize().fee(BigInt(feeRate));
+        if (feeAmount > totalAmount) {
+            throw new Error("fee amount is greater than the total amount");
+        }
+        tx.addOutputAddress(outputAddress, totalAmount - feeAmount);
+        const signedTx = await wallet.identity.sign(tx);
+        signedTx.finalize();
+        await wallet.onchainProvider.broadcastTransaction(signedTx.hex);
+        return signedTx.id;
+    }
+    Unroll.completeUnroll = completeUnroll;
+})(Unroll || (Unroll = {}));
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function doUnroll(bumper, onchainProvider, tx) {
+    return async () => {
+        const [parent, child] = await bumper.bumpP2A(tx);
+        await onchainProvider.broadcastTransaction(parent, child);
+    };
+}
+function doWait(onchainProvider, txid) {
+    return () => {
+        return new Promise((resolve, reject) => {
+            const interval = setInterval(async () => {
+                try {
+                    const txInfo = await onchainProvider.getTxStatus(txid);
+                    if (txInfo.confirmed) {
+                        clearInterval(interval);
+                        resolve();
+                    }
+                }
+                catch (e) {
+                    clearInterval(interval);
+                    reject(e);
+                }
+            }, 5000);
+        });
+    };
+}
+function availableExitPath(confirmedAt, current, vtxo) {
+    const exits = VtxoScript.decode(vtxo.tapTree).exitPaths();
+    for (const exit of exits) {
+        if (exit.params.timelock.type === "blocks") {
+            if (current.height >=
+                confirmedAt.height + Number(exit.params.timelock.value)) {
+                return exit;
+            }
+        }
+        else {
+            if (current.time >=
+                confirmedAt.time + Number(exit.params.timelock.value)) {
+                return exit;
+            }
+        }
+    }
+    return undefined;
+}