@arkade-os/sdk 0.4.5 → 0.4.7

package/README.md

@@ -310,21 +310,62 @@ const settleTxid = await wallet.settle({
 
 ### VTXO Management (Renewal & Recovery)
 
-VTXOs have an expiration time (batch expiry). The SDK provides the `VtxoManager` class to handle both:
+VTXOs have an expiration time (batch expiry). The SDK provides the `VtxoManager` class to handle:
 
 - **Renewal**: Renew VTXOs before they expire to maintain unilateral control of the funds.
 - **Recovery**: Reclaim swept or expired VTXOs back to the wallet in case renewal window was missed.
+- **Boarding UTXO Sweep**: Sweep expired boarding UTXOs back to a fresh boarding address to restart the timelock.
+
+#### Settlement Configuration
+
+The recommended way to configure `VtxoManager` is via `settlementConfig` on the wallet.
+If you omit `settlementConfig`, settlement is enabled with the default behavior:
+VTXO renewal at 3 days and boarding UTXO sweep enabled.
 
 ```typescript
-import { VtxoManager } from '@arkade-os/sdk'
+const wallet = await Wallet.create({
+  identity,
+  arkServerUrl: 'https://mutinynet.arkade.sh',
+  // Enable settlement with defaults explicitly
+  settlementConfig: {},
+})
+```
 
-// Create manager with optional renewal configuration
-const manager = new VtxoManager(wallet, {
-  enabled: true,                   // Enable expiration monitoring
-  thresholdMs: 24 * 60 * 60 * 1000 // Alert when 24h hours % of lifetime remains (default)
+```typescript
+// Enable both VTXO renewal and boarding UTXO sweep
+const wallet = await Wallet.create({
+  identity,
+  arkServerUrl: 'https://mutinynet.arkade.sh',
+  settlementConfig: {
+    vtxoThreshold: 86400,      // renew when 24 hours remain (in seconds)
+    boardingUtxoSweep: true,   // sweep expired boarding UTXOs
+  },
 })
 ```
 
+```typescript
+// Explicitly disable all settlement
+const wallet = await Wallet.create({
+  identity,
+  arkServerUrl: 'https://mutinynet.arkade.sh',
+  settlementConfig: false,
+})
+```
+
+Create the `VtxoManager` by passing the wallet and its settlement config:
+
+```typescript
+import { VtxoManager } from '@arkade-os/sdk'
+
+const manager = new VtxoManager(
+  wallet,
+  undefined,               // deprecated renewalConfig
+  wallet.settlementConfig  // new settlementConfig
+)
+```
+
+> **Migration from `renewalConfig`:** The old `renewalConfig` with `enabled` and `thresholdMs` (milliseconds) is still supported but deprecated. If both are provided, `settlementConfig` takes precedence. The new `vtxoThreshold` uses **seconds** instead of milliseconds.
+
 #### Renewal: Prevent Expiration
 
 Renew VTXOs before they expire to retain unilateral control of funds.
@@ -341,6 +382,26 @@ const expiringVtxos = await manager.getExpiringVtxos()
 const urgentlyExpiring = await manager.getExpiringVtxos(5_000)
 ```
 
+#### Boarding UTXO Sweep
+
+When a boarding UTXO's CSV timelock expires, it can no longer be onboarded into Ark cooperatively. The sweep feature detects these expired UTXOs and builds a raw on-chain transaction that spends them via the unilateral exit path back to a fresh boarding address, restarting the timelock.
+
+- Multiple expired UTXOs are batched into a single transaction (many inputs, one output)
+- A dust check ensures the sweep is skipped if fees would consume the entire value
+
+```typescript
+// Check for expired boarding UTXOs
+const expired = await manager.getExpiredBoardingUtxos()
+console.log(`${expired.length} expired boarding UTXOs`)
+
+// Sweep them back to a fresh boarding address (requires boardingUtxoSweep: true)
+try {
+  const txid = await manager.sweepExpiredBoardingUtxos()
+  console.log('Swept expired boarding UTXOs:', txid)
+} catch (e) {
+  // "No expired boarding UTXOs to sweep" or "Sweep not economical"
+}
+```
 
 #### Recovery: Reclaim Swept VTXOs
 

package/dist/cjs/utils/arkTransaction.js

@@ -121,13 +121,17 @@ const nLocktimeMinSeconds = 500000000n;
 function isSeconds(locktime) {
     return locktime >= nLocktimeMinSeconds;
 }
-function hasBoardingTxExpired(coin, boardingTimelock) {
+function hasBoardingTxExpired(coin, boardingTimelock, chainTipHeight) {
     if (!coin.status.block_time)
         return false;
     if (boardingTimelock.value === 0n)
         return true;
-    if (boardingTimelock.type === "blocks")
-        return false; // TODO: handle get chain tip
+    if (boardingTimelock.type === "blocks") {
+        if (chainTipHeight === undefined || !coin.status.block_height)
+            return false;
+        return (BigInt(chainTipHeight - coin.status.block_height) >=
+            boardingTimelock.value);
+    }
     // validate expiry in terms of seconds
     const now = BigInt(Math.floor(Date.now() / 1000));
     const blockTime = BigInt(Math.floor(coin.status.block_time));

package/dist/cjs/wallet/expo/wallet.js

@@ -192,6 +192,7 @@ class ExpoWallet {
         catch {
             // expo-background-task not installed — nothing to unregister
         }
+        await this.wallet.dispose();
     }
     // ── IWallet delegation ───────────────────────────────────────────
     getAddress() {

package/dist/cjs/wallet/serviceWorker/wallet-message-handler.js

@@ -580,6 +580,20 @@ class WalletMessageHandler {
             this.contractEventsSubscription();
             this.contractEventsSubscription = undefined;
         }
+        // Dispose the wallet to stop the ContractWatcher (and its polling
+        // intervals) before clearing the repositories, otherwise the poller
+        // will hit a closing IndexedDB connection.
+        try {
+            if (this.wallet) {
+                await this.wallet.dispose();
+            }
+            else {
+                await this.readonlyWallet.dispose();
+            }
+        }
+        catch (_) {
+            // best-effort teardown
+        }
         try {
             await this.walletRepository?.clear();
         }

package/dist/cjs/wallet/vtxo-manager.js

@@ -1,16 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VtxoManager = exports.DEFAULT_RENEWAL_CONFIG = exports.DEFAULT_THRESHOLD_MS = void 0;
+exports.VtxoManager = exports.DEFAULT_SETTLEMENT_CONFIG = exports.DEFAULT_RENEWAL_CONFIG = exports.DEFAULT_THRESHOLD_SECONDS = exports.DEFAULT_THRESHOLD_MS = void 0;
 exports.isVtxoExpiringSoon = isVtxoExpiringSoon;
 exports.getExpiringAndRecoverableVtxos = getExpiringAndRecoverableVtxos;
 const _1 = require(".");
+const arkTransaction_1 = require("../utils/arkTransaction");
+const tapscript_1 = require("../script/tapscript");
+const base_1 = require("@scure/base");
+const base_2 = require("../script/base");
+const transaction_1 = require("../utils/transaction");
+const txSizeEstimator_1 = require("../utils/txSizeEstimator");
+/** Type guard to check if a wallet has the properties needed for sweep operations. */
+function isSweepCapable(wallet) {
+    return ("boardingTapscript" in wallet &&
+        "onchainProvider" in wallet &&
+        "network" in wallet);
+}
+/** Asserts that the wallet supports sweep operations, throwing a clear error if not. */
+function assertSweepCapable(wallet) {
+    if (!isSweepCapable(wallet)) {
+        throw new Error("Boarding UTXO sweep requires a Wallet instance with boardingTapscript, onchainProvider, and network");
+    }
+}
 exports.DEFAULT_THRESHOLD_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+exports.DEFAULT_THRESHOLD_SECONDS = 3 * 24 * 60 * 60; // 3 days
 /**
  * Default renewal configuration values
+ * @deprecated Use DEFAULT_SETTLEMENT_CONFIG instead
  */
 exports.DEFAULT_RENEWAL_CONFIG = {
     thresholdMs: exports.DEFAULT_THRESHOLD_MS, // 3 days
 };
+/**
+ * Default settlement configuration values
+ */
+exports.DEFAULT_SETTLEMENT_CONFIG = {
+    vtxoThreshold: exports.DEFAULT_THRESHOLD_SECONDS,
+    boardingUtxoSweep: true,
+    pollIntervalMs: 60000,
+};
+/** Extracts the dust amount from the wallet, defaulting to 330 sats. */
 function getDustAmount(wallet) {
     return "dustAmount" in wallet ? wallet.dustAmount : 330n;
 }
@@ -157,9 +186,38 @@ function getExpiringAndRecoverableVtxos(vtxos, thresholdMs, dustAmount) {
  * ```
  */
 class VtxoManager {
-    constructor(wallet, renewalConfig) {
+    constructor(wallet, 
+    /** @deprecated Use settlementConfig instead */
+    renewalConfig, settlementConfig) {
         this.wallet = wallet;
         this.renewalConfig = renewalConfig;
+        this.knownBoardingUtxos = new Set();
+        this.sweptBoardingUtxos = new Set();
+        this.pollInProgress = false;
+        // Normalize: prefer settlementConfig, fall back to renewalConfig, default to enabled
+        if (settlementConfig !== undefined) {
+            this.settlementConfig = settlementConfig;
+        }
+        else if (renewalConfig && renewalConfig.enabled) {
+            this.settlementConfig = {
+                vtxoThreshold: renewalConfig.thresholdMs
+                    ? renewalConfig.thresholdMs / 1000
+                    : undefined,
+            };
+        }
+        else if (renewalConfig) {
+            // renewalConfig provided but not enabled → disabled
+            this.settlementConfig = false;
+        }
+        else {
+            // No config at all → enabled by default
+            this.settlementConfig = { ...exports.DEFAULT_SETTLEMENT_CONFIG };
+        }
+        this.contractEventsSubscriptionReady =
+            this.initializeSubscription().then((subscription) => {
+                this.contractEventsSubscription = subscription;
+                return subscription;
+            });
     }
     // ========== Recovery Methods ==========
     /**
@@ -271,10 +329,26 @@ class VtxoManager {
      * ```
      */
     async getExpiringVtxos(thresholdMs) {
+        // If settlementConfig is explicitly false and no override provided, renewal is disabled
+        if (this.settlementConfig === false && thresholdMs === undefined) {
+            return [];
+        }
         const vtxos = await this.wallet.getVtxos({ withRecoverable: true });
-        const threshold = thresholdMs ??
-            this.renewalConfig?.thresholdMs ??
-            exports.DEFAULT_RENEWAL_CONFIG.thresholdMs;
+        // Resolve threshold: method param > settlementConfig (seconds→ms) > renewalConfig > default
+        let threshold;
+        if (thresholdMs !== undefined) {
+            threshold = thresholdMs;
+        }
+        else if (this.settlementConfig !== false &&
+            this.settlementConfig &&
+            this.settlementConfig.vtxoThreshold !== undefined) {
+            threshold = this.settlementConfig.vtxoThreshold * 1000;
+        }
+        else {
+            threshold =
+                this.renewalConfig?.thresholdMs ??
+                    exports.DEFAULT_RENEWAL_CONFIG.thresholdMs;
+        }
         return getExpiringAndRecoverableVtxos(vtxos, threshold, getDustAmount(this.wallet));
     }
     /**
@@ -304,7 +378,11 @@ class VtxoManager {
      */
     async renewVtxos(eventCallback) {
         // Get all VTXOs (including recoverable ones)
-        const vtxos = await this.getExpiringVtxos();
+        // Use default threshold to bypass settlementConfig gate (manual API should always work)
+        const vtxos = await this.getExpiringVtxos(this.settlementConfig !== false &&
+            this.settlementConfig?.vtxoThreshold !== undefined
+            ? this.settlementConfig.vtxoThreshold * 1000
+            : exports.DEFAULT_RENEWAL_CONFIG.thresholdMs);
         if (vtxos.length === 0) {
             throw new Error("No VTXOs available to renew");
         }
@@ -326,5 +404,312 @@ class VtxoManager {
             ],
         }, eventCallback);
     }
+    // ========== Boarding UTXO Sweep Methods ==========
+    /**
+     * Get boarding UTXOs whose timelock has expired.
+     *
+     * These UTXOs can no longer be onboarded cooperatively via `settle()` and
+     * must be swept back to a fresh boarding address using the unilateral exit path.
+     *
+     * @returns Array of expired boarding UTXOs
+     *
+     * @example
+     * ```typescript
+     * const manager = new VtxoManager(wallet);
+     * const expired = await manager.getExpiredBoardingUtxos();
+     * if (expired.length > 0) {
+     *   console.log(`${expired.length} expired boarding UTXOs to sweep`);
+     * }
+     * ```
+     */
+    async getExpiredBoardingUtxos() {
+        const boardingUtxos = await this.wallet.getBoardingUtxos();
+        const boardingTimelock = this.getBoardingTimelock();
+        // For block-based timelocks, fetch the chain tip height
+        let chainTipHeight;
+        if (boardingTimelock.type === "blocks") {
+            const tip = await this.getOnchainProvider().getChainTip();
+            chainTipHeight = tip.height;
+        }
+        return boardingUtxos.filter((utxo) => (0, arkTransaction_1.hasBoardingTxExpired)(utxo, boardingTimelock, chainTipHeight));
+    }
+    /**
+     * Sweep expired boarding UTXOs back to a fresh boarding address via
+     * the unilateral exit path (on-chain self-spend).
+     *
+     * This builds a raw on-chain transaction that:
+     * - Uses all expired boarding UTXOs as inputs (spent via the CSV exit script path)
+     * - Has a single output to the wallet's boarding address (restarts the timelock)
+     * - Batches multiple expired UTXOs into one transaction
+     * - Skips the sweep if the output after fees would be below dust
+     *
+     * No Ark server involvement is needed — this is a pure on-chain transaction.
+     *
+     * @returns The broadcast transaction ID
+     * @throws Error if no expired boarding UTXOs found
+     * @throws Error if output after fees is below dust (not economical to sweep)
+     * @throws Error if boarding UTXO sweep is not enabled in settlementConfig
+     *
+     * @example
+     * ```typescript
+     * const manager = new VtxoManager(wallet, undefined, {
+     *   boardingUtxoSweep: true,
+     * });
+     *
+     * try {
+     *   const txid = await manager.sweepExpiredBoardingUtxos();
+     *   console.log('Swept expired boarding UTXOs:', txid);
+     * } catch (e) {
+     *   console.log('No sweep needed or not economical');
+     * }
+     * ```
+     */
+    async sweepExpiredBoardingUtxos() {
+        const sweepEnabled = this.settlementConfig !== false &&
+            (this.settlementConfig?.boardingUtxoSweep ??
+                exports.DEFAULT_SETTLEMENT_CONFIG.boardingUtxoSweep);
+        if (!sweepEnabled) {
+            throw new Error("Boarding UTXO sweep is not enabled in settlementConfig");
+        }
+        const allExpired = await this.getExpiredBoardingUtxos();
+        // Filter out UTXOs already swept (tx broadcast but not yet confirmed)
+        const expiredUtxos = allExpired.filter((u) => !this.sweptBoardingUtxos.has(`${u.txid}:${u.vout}`));
+        if (expiredUtxos.length === 0) {
+            throw new Error("No expired boarding UTXOs to sweep");
+        }
+        const boardingAddress = await this.wallet.getBoardingAddress();
+        // Get fee rate from onchain provider
+        const feeRate = (await this.getOnchainProvider().getFeeRate()) ?? 1;
+        // Get the exit tap leaf script for signing
+        const exitTapLeafScript = this.getBoardingExitLeaf();
+        // Estimate transaction size for fee calculation
+        const sequence = (0, base_2.getSequence)(exitTapLeafScript);
+        // TapLeafScript: [{version, internalKey, merklePath}, scriptWithVersion]
+        const leafScript = exitTapLeafScript[1];
+        const leafScriptSize = leafScript.length - 1; // minus version byte
+        const controlBlockSize = exitTapLeafScript[0].merklePath.length * 32;
+        // Exit path witness: 1 Schnorr signature (64 bytes)
+        const leafWitnessSize = 64;
+        const estimator = txSizeEstimator_1.TxWeightEstimator.create();
+        for (const _ of expiredUtxos) {
+            estimator.addTapscriptInput(leafWitnessSize, leafScriptSize, controlBlockSize);
+        }
+        estimator.addOutputAddress(boardingAddress, this.getNetwork());
+        const fee = Math.ceil(Number(estimator.vsize().value) * feeRate);
+        const totalValue = expiredUtxos.reduce((sum, utxo) => sum + BigInt(utxo.value), 0n);
+        const outputAmount = totalValue - BigInt(fee);
+        // Dust check: skip if output after fees is below dust
+        const dustAmount = getDustAmount(this.wallet);
+        if (outputAmount < dustAmount) {
+            throw new Error(`Sweep not economical: output ${outputAmount} sats after ${fee} sats fee is below dust (${dustAmount} sats)`);
+        }
+        // Build the raw transaction
+        const tx = new transaction_1.Transaction();
+        for (const utxo of expiredUtxos) {
+            tx.addInput({
+                txid: utxo.txid,
+                index: utxo.vout,
+                witnessUtxo: {
+                    script: this.getBoardingOutputScript(),
+                    amount: BigInt(utxo.value),
+                },
+                tapLeafScript: [exitTapLeafScript],
+                sequence,
+            });
+        }
+        tx.addOutputAddress(boardingAddress, outputAmount, this.getNetwork());
+        // Sign and finalize
+        const signedTx = await this.getIdentity().sign(tx);
+        signedTx.finalize();
+        // Broadcast
+        const txid = await this.getOnchainProvider().broadcastTransaction(signedTx.hex);
+        // Mark UTXOs as swept to prevent duplicate broadcasts on next poll
+        for (const u of expiredUtxos) {
+            this.sweptBoardingUtxos.add(`${u.txid}:${u.vout}`);
+        }
+        // Mark the sweep output as "known" so the next poll doesn't try to
+        // auto-settle it back into Ark (it lands at the same boarding address).
+        this.knownBoardingUtxos.add(`${txid}:0`);
+        return txid;
+    }
+    // ========== Private Helpers ==========
+    /** Asserts sweep capability and returns the typed wallet. */
+    getSweepWallet() {
+        assertSweepCapable(this.wallet);
+        return this.wallet;
+    }
+    /** Decodes the boarding tapscript exit path to extract the CSV timelock. */
+    getBoardingTimelock() {
+        const wallet = this.getSweepWallet();
+        const exitScript = tapscript_1.CSVMultisigTapscript.decode(base_1.hex.decode(wallet.boardingTapscript.exitScript));
+        return exitScript.params.timelock;
+    }
+    /** Returns the TapLeafScript for the boarding tapscript's exit (CSV) path. */
+    getBoardingExitLeaf() {
+        return this.getSweepWallet().boardingTapscript.exit();
+    }
+    /** Returns the pkScript (output script) of the boarding tapscript. */
+    getBoardingOutputScript() {
+        return this.getSweepWallet().boardingTapscript.pkScript;
+    }
+    /** Returns the on-chain provider for fee estimation and broadcasting. */
+    getOnchainProvider() {
+        return this.getSweepWallet().onchainProvider;
+    }
+    /** Returns the Bitcoin network configuration from the wallet. */
+    getNetwork() {
+        return this.getSweepWallet().network;
+    }
+    /** Returns the wallet's identity for transaction signing. */
+    getIdentity() {
+        return this.wallet.identity;
+    }
+    async initializeSubscription() {
+        if (this.settlementConfig === false) {
+            return undefined;
+        }
+        // Start polling for boarding UTXOs independently of contract manager
+        // SSE setup. Use a short delay to let the wallet finish construction.
+        setTimeout(() => this.startBoardingUtxoPoll(), 1000);
+        try {
+            const [delegatorManager, contractManager, destination] = await Promise.all([
+                this.wallet.getDelegatorManager(),
+                this.wallet.getContractManager(),
+                this.wallet.getAddress(),
+            ]);
+            const stopWatching = contractManager.onContractEvent((event) => {
+                if (event.type !== "vtxo_received") {
+                    return;
+                }
+                this.renewVtxos().catch((e) => {
+                    if (e instanceof Error) {
+                        if (e.message.includes("No VTXOs available to renew")) {
+                            // Not an error, just no VTXO eligible for renewal.
+                            return;
+                        }
+                        if (e.message.includes("is below dust threshold")) {
+                            // Not an error, just below dust threshold.
+                            // As more VTXOs are received, the threshold will be raised.
+                            return;
+                        }
+                    }
+                    console.error("Error renewing VTXOs:", e);
+                });
+                delegatorManager
+                    ?.delegate(event.vtxos, destination)
+                    .catch((e) => {
+                    console.error("Error delegating VTXOs:", e);
+                });
+            });
+            return stopWatching;
+        }
+        catch (e) {
+            console.error("Error renewing VTXOs from VtxoManager", e);
+            return undefined;
+        }
+    }
+    /**
+     * Starts a polling loop that:
+     * 1. Auto-settles new boarding UTXOs into Ark
+     * 2. Sweeps expired boarding UTXOs (when boardingUtxoSweep is enabled)
+     */
+    startBoardingUtxoPoll() {
+        if (this.settlementConfig === false)
+            return;
+        const intervalMs = this.settlementConfig.pollIntervalMs ??
+            exports.DEFAULT_SETTLEMENT_CONFIG.pollIntervalMs;
+        // Run once immediately, then on interval
+        this.pollBoardingUtxos();
+        this.pollIntervalId = setInterval(() => this.pollBoardingUtxos(), intervalMs);
+    }
+    async pollBoardingUtxos() {
+        // Guard: wallet must support boarding UTXO + sweep operations
+        if (!isSweepCapable(this.wallet))
+            return;
+        // Skip if a previous poll is still running
+        if (this.pollInProgress)
+            return;
+        this.pollInProgress = true;
+        try {
+            // Settle new (unexpired) UTXOs first, then sweep expired ones.
+            // Sequential to avoid racing for the same UTXOs.
+            try {
+                await this.settleBoardingUtxos();
+            }
+            catch (e) {
+                console.error("Error auto-settling boarding UTXOs:", e);
+            }
+            const sweepEnabled = this.settlementConfig !== false &&
+                (this.settlementConfig?.boardingUtxoSweep ??
+                    exports.DEFAULT_SETTLEMENT_CONFIG.boardingUtxoSweep);
+            if (sweepEnabled) {
+                try {
+                    await this.sweepExpiredBoardingUtxos();
+                }
+                catch (e) {
+                    if (!(e instanceof Error) ||
+                        !e.message.includes("No expired boarding UTXOs")) {
+                        console.error("Error auto-sweeping boarding UTXOs:", e);
+                    }
+                }
+            }
+        }
+        finally {
+            this.pollInProgress = false;
+        }
+    }
+    /**
+     * Auto-settle new (unexpired) boarding UTXOs into the Ark.
+     * Skips UTXOs that are already expired (those are handled by sweep).
+     * Only settles UTXOs not already in-flight (tracked in knownBoardingUtxos).
+     * UTXOs are marked as known only after a successful settle, so failed
+     * attempts will be retried on the next poll.
+     */
+    async settleBoardingUtxos() {
+        const boardingUtxos = await this.wallet.getBoardingUtxos();
+        // Exclude expired UTXOs — those should be swept, not settled.
+        // If we can't determine expired status, bail out entirely to avoid
+        // accidentally settling expired UTXOs (which would conflict with sweep).
+        let expiredSet;
+        try {
+            const expired = await this.getExpiredBoardingUtxos();
+            expiredSet = new Set(expired.map((u) => `${u.txid}:${u.vout}`));
+        }
+        catch {
+            return;
+        }
+        const unsettledUtxos = boardingUtxos.filter((u) => !this.knownBoardingUtxos.has(`${u.txid}:${u.vout}`) &&
+            !expiredSet.has(`${u.txid}:${u.vout}`));
+        if (unsettledUtxos.length === 0)
+            return;
+        const dustAmount = getDustAmount(this.wallet);
+        const totalAmount = unsettledUtxos.reduce((sum, u) => sum + BigInt(u.value), 0n);
+        if (totalAmount < dustAmount)
+            return;
+        const arkAddress = await this.wallet.getAddress();
+        await this.wallet.settle({
+            inputs: unsettledUtxos,
+            outputs: [{ address: arkAddress, amount: totalAmount }],
+        });
+        // Mark as known only after successful settle
+        for (const u of unsettledUtxos) {
+            this.knownBoardingUtxos.add(`${u.txid}:${u.vout}`);
+        }
+    }
+    async dispose() {
+        this.disposePromise ?? (this.disposePromise = (async () => {
+            if (this.pollIntervalId) {
+                clearInterval(this.pollIntervalId);
+                this.pollIntervalId = undefined;
+            }
+            const subscription = await this.contractEventsSubscriptionReady;
+            this.contractEventsSubscription = undefined;
+            subscription?.();
+        })());
+        return this.disposePromise;
+    }
+    async [Symbol.asyncDispose]() {
+        await this.dispose();
+    }
 }
 exports.VtxoManager = VtxoManager;