@arkade-os/sdk 0.4.5 → 0.4.6

package/dist/cjs/wallet/wallet.js

@@ -616,6 +616,18 @@ class ReadonlyWallet {
         }
         return manager;
     }
+    async dispose() {
+        const manager = this._contractManager ??
+            (this._contractManagerInitializing
+                ? await this._contractManagerInitializing.catch(() => undefined)
+                : undefined);
+        manager?.dispose();
+        this._contractManager = undefined;
+        this._contractManagerInitializing = undefined;
+    }
+    async [Symbol.asyncDispose]() {
+        await this.dispose();
+    }
 }
 exports.ReadonlyWallet = ReadonlyWallet;
 /**
@@ -652,7 +664,9 @@ exports.ReadonlyWallet = ReadonlyWallet;
  * ```
  */
 class Wallet extends ReadonlyWallet {
-    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, renewalConfig, delegatorProvider, watcherConfig) {
+    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, 
+    /** @deprecated Use settlementConfig */
+    renewalConfig, delegatorProvider, watcherConfig, settlementConfig) {
         super(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegatorProvider, watcherConfig);
         this.networkName = networkName;
         this.arkProvider = arkProvider;
@@ -660,11 +674,31 @@ class Wallet extends ReadonlyWallet {
         this.forfeitOutputScript = forfeitOutputScript;
         this.forfeitPubkey = forfeitPubkey;
         this.identity = identity;
+        // Backwards-compatible: keep renewalConfig populated for any code reading it
         this.renewalConfig = {
             enabled: renewalConfig?.enabled ?? false,
             ...vtxo_manager_1.DEFAULT_RENEWAL_CONFIG,
             ...renewalConfig,
         };
+        // Normalize: prefer settlementConfig, fall back to renewalConfig, default to enabled
+        if (settlementConfig !== undefined) {
+            this.settlementConfig = settlementConfig;
+        }
+        else if (renewalConfig && this.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 = { ...vtxo_manager_1.DEFAULT_SETTLEMENT_CONFIG };
+        }
         this._delegatorManager = delegatorProvider
             ? new delegator_1.DelegatorManagerImpl(delegatorProvider, arkProvider, identity)
             : undefined;
@@ -673,6 +707,46 @@ class Wallet extends ReadonlyWallet {
         this._walletAssetManager ?? (this._walletAssetManager = new asset_manager_1.AssetManager(this));
         return this._walletAssetManager;
     }
+    async getVtxoManager() {
+        if (this._vtxoManager) {
+            return this._vtxoManager;
+        }
+        if (this._vtxoManagerInitializing) {
+            return this._vtxoManagerInitializing;
+        }
+        this._vtxoManagerInitializing = Promise.resolve(new vtxo_manager_1.VtxoManager(this, this.renewalConfig, this.settlementConfig));
+        try {
+            const manager = await this._vtxoManagerInitializing;
+            this._vtxoManager = manager;
+            return manager;
+        }
+        catch (error) {
+            this._vtxoManagerInitializing = undefined;
+            throw error;
+        }
+        finally {
+            this._vtxoManagerInitializing = undefined;
+        }
+    }
+    async dispose() {
+        const manager = this._vtxoManager ??
+            (this._vtxoManagerInitializing
+                ? await this._vtxoManagerInitializing.catch(() => undefined)
+                : undefined);
+        try {
+            if (manager) {
+                await manager.dispose();
+            }
+        }
+        catch {
+            // best-effort teardown; ensure super.dispose() still runs
+        }
+        finally {
+            this._vtxoManager = undefined;
+            this._vtxoManagerInitializing = undefined;
+            await super.dispose();
+        }
+    }
     static async create(config) {
         const pubkey = await config.identity.xOnlyPublicKey();
         if (!pubkey) {
@@ -694,7 +768,9 @@ class Wallet extends ReadonlyWallet {
         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, config.delegatorProvider, config.watcherConfig);
+        const wallet = 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, config.delegatorProvider, config.watcherConfig, config.settlementConfig);
+        await wallet.getVtxoManager();
+        return wallet;
     }
     /**
      * Convert this wallet to a readonly wallet.
@@ -797,7 +873,13 @@ class Wallet extends ReadonlyWallet {
             let amount = 0;
             const exitScript = tapscript_1.CSVMultisigTapscript.decode(base_1.hex.decode(this.boardingTapscript.exitScript));
             const boardingTimelock = exitScript.params.timelock;
-            const boardingUtxos = (await this.getBoardingUtxos()).filter((utxo) => !(0, arkTransaction_1.hasBoardingTxExpired)(utxo, boardingTimelock));
+            // For block-based timelocks, fetch the chain tip height
+            let chainTipHeight;
+            if (boardingTimelock.type === "blocks") {
+                const tip = await this.onchainProvider.getChainTip();
+                chainTipHeight = tip.height;
+            }
+            const boardingUtxos = (await this.getBoardingUtxos()).filter((utxo) => !(0, arkTransaction_1.hasBoardingTxExpired)(utxo, boardingTimelock, chainTipHeight));
             const filteredBoardingUtxos = [];
             for (const utxo of boardingUtxos) {
                 const inputFee = estimator.evalOnchainInput({

package/dist/esm/utils/arkTransaction.js

@@ -114,13 +114,17 @@ const nLocktimeMinSeconds = 500000000n;
 function isSeconds(locktime) {
     return locktime >= nLocktimeMinSeconds;
 }
-export function hasBoardingTxExpired(coin, boardingTimelock) {
+export 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/esm/wallet/expo/wallet.js

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

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

@@ -577,6 +577,20 @@ export 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/esm/wallet/vtxo-manager.js

@@ -1,11 +1,40 @@
 import { isExpired, isRecoverable, isSpendable, isSubdust, } from './index.js';
+import { hasBoardingTxExpired } from '../utils/arkTransaction.js';
+import { CSVMultisigTapscript } from '../script/tapscript.js';
+import { hex } from "@scure/base";
+import { getSequence } from '../script/base.js';
+import { Transaction } from '../utils/transaction.js';
+import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
+/** 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");
+    }
+}
 export const DEFAULT_THRESHOLD_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+export const DEFAULT_THRESHOLD_SECONDS = 3 * 24 * 60 * 60; // 3 days
 /**
  * Default renewal configuration values
+ * @deprecated Use DEFAULT_SETTLEMENT_CONFIG instead
  */
 export const DEFAULT_RENEWAL_CONFIG = {
     thresholdMs: DEFAULT_THRESHOLD_MS, // 3 days
 };
+/**
+ * Default settlement configuration values
+ */
+export const DEFAULT_SETTLEMENT_CONFIG = {
+    vtxoThreshold: 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;
 }
@@ -152,9 +181,38 @@ export function getExpiringAndRecoverableVtxos(vtxos, thresholdMs, dustAmount) {
  * ```
  */
 export 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 = { ...DEFAULT_SETTLEMENT_CONFIG };
+        }
+        this.contractEventsSubscriptionReady =
+            this.initializeSubscription().then((subscription) => {
+                this.contractEventsSubscription = subscription;
+                return subscription;
+            });
     }
     // ========== Recovery Methods ==========
     /**
@@ -266,10 +324,26 @@ export 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 ??
-            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 ??
+                    DEFAULT_RENEWAL_CONFIG.thresholdMs;
+        }
         return getExpiringAndRecoverableVtxos(vtxos, threshold, getDustAmount(this.wallet));
     }
     /**
@@ -299,7 +373,11 @@ export 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
+            : DEFAULT_RENEWAL_CONFIG.thresholdMs);
         if (vtxos.length === 0) {
             throw new Error("No VTXOs available to renew");
         }
@@ -321,4 +399,300 @@ export 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) => 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 ??
+                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 = 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 = 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();
+        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 = CSVMultisigTapscript.decode(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) => {
+                    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 ??
+            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 ??
+                    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();
+    }
 }