@arkade-os/sdk 0.3.12 → 0.4.0-next.0

package/dist/esm/wallet/wallet.js

@@ -1,7 +1,6 @@
 import { base64, hex } from "@scure/base";
-import * as bip68 from "bip68";
 import { tapLeafHash } from "@scure/btc-signer/payment.js";
-import { SigHash, Transaction, Address, OutScript } from "@scure/btc-signer";
+import { Address, OutScript, SigHash, Transaction } from "@scure/btc-signer";
 import { sha256 } from "@scure/btc-signer/utils.js";
 import { ArkAddress } from '../script/address.js';
 import { DefaultVtxo } from '../script/default.js';
@@ -10,23 +9,28 @@ import { ESPLORA_URL, EsploraProvider, } from '../providers/onchain.js';
 import { RestArkProvider, } from '../providers/ark.js';
 import { buildForfeitTx } from '../forfeit.js';
 import { validateConnectorsTxGraph, validateVtxoTxGraph, } from '../tree/validation.js';
+import { validateBatchRecipients } from './validation.js';
 import { isExpired, isRecoverable, isSpendable, isSubdust, TxType, } from './index.js';
+import { createAssetPacket, selectedCoinsToAssetInputs, selectCoinsWithAsset, } from './asset.js';
 import { VtxoScript } from '../script/base.js';
-import { CLTVMultisigTapscript, CSVMultisigTapscript, } from '../script/tapscript.js';
-import { buildOffchainTx, hasBoardingTxExpired } from '../utils/arkTransaction.js';
+import { CSVMultisigTapscript } from '../script/tapscript.js';
+import { buildOffchainTx, hasBoardingTxExpired, isValidArkAddress, } from '../utils/arkTransaction.js';
 import { DEFAULT_RENEWAL_CONFIG } from './vtxo-manager.js';
 import { ArkNote } from '../arknote/index.js';
 import { Intent } from '../intent/index.js';
 import { RestIndexerProvider } from '../providers/indexer.js';
-import { ConditionWitness, VtxoTaprootTree } from '../utils/unknownFields.js';
-import { InMemoryStorageAdapter } from '../storage/inMemory.js';
-import { WalletRepositoryImpl, } from '../repositories/walletRepository.js';
-import { ContractRepositoryImpl, } from '../repositories/contractRepository.js';
-import { extendCoin, extendVirtualCoin } from './utils.js';
+import { extendCoin, extendVirtualCoin, validateRecipients } from './utils.js';
 import { ArkError } from '../providers/errors.js';
 import { Batch } from './batch.js';
 import { Estimator } from '../arkfee/index.js';
 import { buildTransactionHistory } from '../utils/transactionHistory.js';
+import { AssetManager, ReadonlyAssetManager } from './asset-manager.js';
+import { DelegateVtxo } from '../script/delegate.js';
+import { DelegatorManagerImpl } from './delegator.js';
+import { IndexedDBContractRepository, IndexedDBWalletRepository, } from '../repositories/index.js';
+import { ContractManager } from '../contracts/contractManager.js';
+import { contractHandlers } from '../contracts/handlers/index.js';
+import { timelockToSequence } from '../contracts/handlers/helpers.js';
 /**
  * Type guard function to check if an identity has a toReadonly method.
  */
@@ -37,7 +41,10 @@ function hasToReadonly(identity) {
         typeof identity.toReadonly === "function");
 }
 export class ReadonlyWallet {
-    constructor(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository) {
+    get assetManager() {
+        return this._assetManager;
+    }
+    constructor(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegatorProvider, watcherConfig) {
         this.identity = identity;
         this.network = network;
         this.onchainProvider = onchainProvider;
@@ -48,12 +55,15 @@ export class ReadonlyWallet {
         this.dustAmount = dustAmount;
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
+        this.delegatorProvider = delegatorProvider;
+        this.watcherConfig = watcherConfig;
+        this._assetManager = new ReadonlyAssetManager(this.indexerProvider);
     }
     /**
      * Protected helper to set up shared wallet configuration.
      * Extracts common logic used by both ReadonlyWallet.create() and Wallet.create().
      */
-    static async setupWalletConfig(config, pubkey) {
+    static async setupWalletConfig(config, pubKey) {
         // Use provided arkProvider instance or create a new one from arkServerUrl
         const arkProvider = config.arkProvider ||
             (() => {
@@ -105,22 +115,26 @@ export class ReadonlyWallet {
         };
         // Generate tapscripts for offchain and boarding address
         const serverPubKey = hex.decode(info.signerPubkey).slice(1);
-        const bareVtxoTapscript = new DefaultVtxo.Script({
-            pubKey: pubkey,
+        const delegatePubKey = config.delegatorProvider
+            ? await config.delegatorProvider
+                .getDelegateInfo()
+                .then((info) => hex.decode(info.pubkey).slice(1))
+            : undefined;
+        const offchainOptions = {
+            pubKey,
             serverPubKey,
             csvTimelock: exitTimelock,
-        });
+        };
+        const offchainTapscript = !delegatePubKey
+            ? new DefaultVtxo.Script(offchainOptions)
+            : new DelegateVtxo.Script({ ...offchainOptions, delegatePubKey });
         const boardingTapscript = new DefaultVtxo.Script({
-            pubKey: pubkey,
-            serverPubKey,
+            ...offchainOptions,
             csvTimelock: boardingTimelock,
         });
-        // Save tapscripts
-        const offchainTapscript = bareVtxoTapscript;
-        // Set up storage and repositories
-        const storage = config.storage || new InMemoryStorageAdapter();
-        const walletRepository = new WalletRepositoryImpl(storage);
-        const contractRepository = new ContractRepositoryImpl(storage);
+        const walletRepository = config.storage?.walletRepository ?? new IndexedDBWalletRepository();
+        const contractRepository = config.storage?.contractRepository ??
+            new IndexedDBContractRepository();
         return {
             arkProvider,
             indexerProvider,
@@ -134,6 +148,7 @@ export class ReadonlyWallet {
             walletRepository,
             contractRepository,
             info,
+            delegatorProvider: config.delegatorProvider,
         };
     }
     static async create(config) {
@@ -142,11 +157,18 @@ export class ReadonlyWallet {
             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);
+        return new ReadonlyWallet(config.identity, setup.network, setup.onchainProvider, setup.indexerProvider, setup.serverPubKey, setup.offchainTapscript, setup.boardingTapscript, setup.dustAmount, setup.walletRepository, setup.contractRepository, setup.delegatorProvider, config.watcherConfig);
     }
     get arkAddress() {
         return this.offchainTapscript.address(this.network.hrp, this.arkServerPublicKey);
     }
+    /**
+     * Get the contract script for the wallet's default address.
+     * This is the pkScript hex, used to identify the wallet in ContractManager.
+     */
+    get defaultContractScript() {
+        return hex.encode(this.offchainTapscript.pkScript);
+    }
     async getAddress() {
         return this.arkAddress.encode();
     }
@@ -184,6 +206,22 @@ export class ReadonlyWallet {
             .reduce((sum, coin) => sum + coin.value, 0);
         const totalBoarding = confirmed + unconfirmed;
         const totalOffchain = settled + preconfirmed + recoverable;
+        // aggregate asset balances from spendable vtxos
+        const assetBalances = new Map();
+        for (const vtxo of vtxos) {
+            if (!isSpendable(vtxo))
+                continue;
+            if (vtxo.assets) {
+                for (const a of vtxo.assets) {
+                    const current = assetBalances.get(a.assetId) ?? 0;
+                    assetBalances.set(a.assetId, current + a.amount);
+                }
+            }
+        }
+        const assets = Array.from(assetBalances.entries()).map(([assetId, amount]) => ({
+            assetId,
+            amount,
+        }));
         return {
             boarding: {
                 confirmed,
@@ -195,20 +233,39 @@ export class ReadonlyWallet {
             available: settled + preconfirmed,
             recoverable,
             total: totalBoarding + totalOffchain,
+            assets,
         };
     }
     async getVtxos(filter) {
         const address = await this.getAddress();
-        // Try to get from cache first first (optional fast path)
-        // const cachedVtxos = await this.walletRepository.getVtxos(address);
-        // if (cachedVtxos.length) return cachedVtxos;
-        // For now, always fetch fresh data from provider and update cache
-        // In future, we can add cache invalidation logic based on timestamps
-        const vtxos = await this.getVirtualCoins(filter);
-        const extendedVtxos = vtxos.map((vtxo) => extendVirtualCoin(this, vtxo));
+        const scriptMap = await this.getScriptMap();
+        const f = filter ?? { withRecoverable: true, withUnrolled: false };
+        const allExtended = [];
+        // Query each script separately so we can extend VTXOs with the correct tapscript
+        for (const [scriptHex, vtxoScript] of scriptMap) {
+            const response = await this.indexerProvider.getVtxos({
+                scripts: [scriptHex],
+            });
+            let vtxos = response.vtxos.filter(isSpendable);
+            if (!f.withRecoverable) {
+                vtxos = vtxos.filter((vtxo) => !isRecoverable(vtxo) && !isExpired(vtxo));
+            }
+            if (f.withUnrolled) {
+                const spentVtxos = response.vtxos.filter((vtxo) => !isSpendable(vtxo));
+                vtxos.push(...spentVtxos.filter((vtxo) => vtxo.isUnrolled));
+            }
+            for (const vtxo of vtxos) {
+                allExtended.push({
+                    ...vtxo,
+                    forfeitTapLeafScript: vtxoScript.forfeit(),
+                    intentTapLeafScript: vtxoScript.forfeit(),
+                    tapTree: vtxoScript.encode(),
+                });
+            }
+        }
         // Update cache with fresh data
-        await this.walletRepository.saveVtxos(address, extendedVtxos);
-        return extendedVtxos;
+        await this.walletRepository.saveVtxos(address, allExtended);
+        return allExtended;
     }
     async getVirtualCoins(filter = { withRecoverable: true, withUnrolled: false }) {
         const scripts = [hex.encode(this.offchainTapscript.pkScript)];
@@ -226,9 +283,8 @@ export class ReadonlyWallet {
         return vtxos;
     }
     async getTransactionHistory() {
-        const response = await this.indexerProvider.getVtxos({
-            scripts: [hex.encode(this.offchainTapscript.pkScript)],
-        });
+        const scripts = await this.getWalletScripts();
+        const response = await this.indexerProvider.getVtxos({ scripts });
         const { boardingTxs, commitmentsToIgnore } = await this.getBoardingTxs();
         const getTxCreatedAt = (txid) => this.indexerProvider
             .getVtxos({ outpoints: [{ txid, vout: 0 }] })
@@ -338,17 +394,20 @@ export class ReadonlyWallet {
             });
         }
         if (this.indexerProvider && arkAddress) {
-            const offchainScript = this.offchainTapscript;
-            const subscriptionId = await this.indexerProvider.subscribeForScripts([
-                hex.encode(offchainScript.pkScript),
-            ]);
+            const walletScripts = await this.getWalletScripts();
+            const subscriptionId = await this.indexerProvider.subscribeForScripts(walletScripts);
             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
+            // Handle subscription updates asynchronously without blocking.
+            // Note: subscription covers all wallet scripts (default + delegate),
+            // but we can't determine which script each VTXO belongs to from the
+            // subscription event. VTXOs are extended with the current offchainTapscript;
+            // this is for notification/display only — not for spending.
+            // For correct extension metadata, use getVtxos() which queries per-script.
             (async () => {
                 try {
                     for await (const update of subscription) {
@@ -375,7 +434,7 @@ export class ReadonlyWallet {
     }
     async fetchPendingTxs() {
         // get non-swept VTXOs, rely on the indexer only in case DB doesn't have the right state
-        const scripts = [hex.encode(this.offchainTapscript.pkScript)];
+        const scripts = await this.getWalletScripts();
         let { vtxos } = await this.indexerProvider.getVtxos({
             scripts,
         });
@@ -385,6 +444,183 @@ export class ReadonlyWallet {
             vtxo.arkTxId !== undefined)
             .map((_) => _.arkTxId);
     }
+    // ========================================================================
+    // Multi-script support (default + delegate addresses)
+    // ========================================================================
+    /**
+     * Get all pkScript hex strings for the wallet's own addresses
+     * (both delegate and non-delegate, current and historical).
+     * Falls back to only the current script if ContractManager is not yet initialized.
+     */
+    async getWalletScripts() {
+        if (this._contractManager) {
+            try {
+                const contracts = await this._contractManager.getContracts({
+                    type: ["default", "delegate"],
+                });
+                if (contracts.length > 0) {
+                    return contracts.map((c) => c.script);
+                }
+            }
+            catch {
+                // fall through to current script only
+            }
+        }
+        return [hex.encode(this.offchainTapscript.pkScript)];
+    }
+    /**
+     * Build a map of scriptHex → VtxoScript for all wallet contracts,
+     * so VTXOs can be extended with the correct tapscript per contract.
+     */
+    async getScriptMap() {
+        const map = new Map();
+        // Always include the current script
+        const currentScriptHex = hex.encode(this.offchainTapscript.pkScript);
+        map.set(currentScriptHex, this.offchainTapscript);
+        if (this._contractManager) {
+            try {
+                const contracts = await this._contractManager.getContracts({
+                    type: ["default", "delegate"],
+                });
+                for (const contract of contracts) {
+                    if (map.has(contract.script))
+                        continue;
+                    const handler = contractHandlers.get(contract.type);
+                    if (handler) {
+                        const script = handler.createScript(contract.params);
+                        map.set(contract.script, script);
+                    }
+                }
+            }
+            catch {
+                // ContractManager error — only current script in map
+            }
+        }
+        return map;
+    }
+    // ========================================================================
+    // Contract Management
+    // ========================================================================
+    /**
+     * Get the ContractManager for managing contracts including the wallet's default address.
+     *
+     * The ContractManager handles:
+     * - The wallet's default receiving address (as a "default" contract)
+     * - External contracts (Boltz swaps, HTLCs, etc.)
+     * - Multi-contract watching with resilient connections
+     *
+     * @example
+     * ```typescript
+     * const manager = await wallet.getContractManager();
+     *
+     * // Create a contract for a Boltz swap
+     * const contract = await manager.createContract({
+     *   label: "Boltz Swap",
+     *   type: "vhtlc",
+     *   params: { ... },
+     *   script: swapScript,
+     *   address: swapAddress,
+     * });
+     *
+     * // Start watching for events (includes wallet's default address)
+     * const stop = await manager.onContractEvent((event) => {
+     *   console.log(`${event.type} on ${event.contractScript}`);
+     * });
+     * ```
+     */
+    async getContractManager() {
+        // Return existing manager if already initialized
+        if (this._contractManager) {
+            return this._contractManager;
+        }
+        // If initialization is in progress, wait for it
+        if (this._contractManagerInitializing) {
+            return this._contractManagerInitializing;
+        }
+        // Start initialization and store the promise
+        this._contractManagerInitializing = this.initializeContractManager();
+        try {
+            const manager = await this._contractManagerInitializing;
+            this._contractManager = manager;
+            return manager;
+        }
+        catch (error) {
+            // Clear the initializing promise so subsequent calls can retry
+            this._contractManagerInitializing = undefined;
+            throw error;
+        }
+        finally {
+            // Clear the initializing promise after completion
+            this._contractManagerInitializing = undefined;
+        }
+    }
+    async initializeContractManager() {
+        const manager = await ContractManager.create({
+            indexerProvider: this.indexerProvider,
+            contractRepository: this.contractRepository,
+            walletRepository: this.walletRepository,
+            getDefaultAddress: () => this.getAddress(),
+            watcherConfig: this.watcherConfig,
+        });
+        // Register the wallet's current address as a contract
+        const csvTimelock = this.offchainTapscript.options.csvTimelock ??
+            DefaultVtxo.Script.DEFAULT_TIMELOCK;
+        const csvTimelockStr = timelockToSequence(csvTimelock).toString();
+        const isDelegateScript = this.offchainTapscript instanceof DelegateVtxo.Script;
+        if (isDelegateScript) {
+            const delegateScript = this
+                .offchainTapscript;
+            // Register the delegate contract (current address)
+            await manager.createContract({
+                type: "delegate",
+                params: {
+                    pubKey: hex.encode(delegateScript.options.pubKey),
+                    serverPubKey: hex.encode(delegateScript.options.serverPubKey),
+                    delegatePubKey: hex.encode(delegateScript.options.delegatePubKey),
+                    csvTimelock: csvTimelockStr,
+                },
+                script: this.defaultContractScript,
+                address: await this.getAddress(),
+                state: "active",
+            });
+            // Also register the non-delegate version so old VTXOs remain visible
+            const nonDelegateScript = new DefaultVtxo.Script({
+                pubKey: delegateScript.options.pubKey,
+                serverPubKey: delegateScript.options.serverPubKey,
+                csvTimelock,
+            });
+            await manager.createContract({
+                type: "default",
+                params: {
+                    pubKey: hex.encode(delegateScript.options.pubKey),
+                    serverPubKey: hex.encode(delegateScript.options.serverPubKey),
+                    csvTimelock: csvTimelockStr,
+                },
+                script: hex.encode(nonDelegateScript.pkScript),
+                address: nonDelegateScript
+                    .address(this.network.hrp, this.arkServerPublicKey)
+                    .encode(),
+                state: "active",
+            });
+        }
+        else {
+            // Register the default contract (current address)
+            await manager.createContract({
+                type: "default",
+                params: {
+                    pubKey: hex.encode(this.offchainTapscript.options.pubKey),
+                    serverPubKey: hex.encode(this.offchainTapscript.options.serverPubKey),
+                    csvTimelock: csvTimelockStr,
+                },
+                script: this.defaultContractScript,
+                address: await this.getAddress(),
+                state: "active",
+            });
+            // Any old "delegate" contract from a prior wallet incarnation
+            // is already loaded by ContractManager.initialize() from ContractRepository
+        }
+        return manager;
+    }
 }
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
@@ -420,8 +656,8 @@ export class ReadonlyWallet {
  * ```
  */
 export class Wallet extends ReadonlyWallet {
-    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, renewalConfig) {
-        super(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository);
+    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, renewalConfig, delegatorProvider, watcherConfig) {
+        super(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegatorProvider, watcherConfig);
         this.networkName = networkName;
         this.arkProvider = arkProvider;
         this.serverUnrollScript = serverUnrollScript;
@@ -433,6 +669,13 @@ export class Wallet extends ReadonlyWallet {
             ...DEFAULT_RENEWAL_CONFIG,
             ...renewalConfig,
         };
+        this.delegatorManager = delegatorProvider
+            ? new DelegatorManagerImpl(delegatorProvider, arkProvider, identity)
+            : undefined;
+    }
+    get assetManager() {
+        this._walletAssetManager ?? (this._walletAssetManager = new AssetManager(this));
+        return this._walletAssetManager;
     }
     static async create(config) {
         const pubkey = await config.identity.xOnlyPublicKey();
@@ -455,7 +698,7 @@ export class Wallet extends ReadonlyWallet {
         const forfeitPubkey = hex.decode(setup.info.forfeitPubkey).slice(1);
         const forfeitAddress = Address(setup.network).decode(setup.info.forfeitAddress);
         const forfeitOutputScript = OutScript.encode(forfeitAddress);
-        return new Wallet(config.identity, setup.network, setup.networkName, setup.onchainProvider, setup.arkProvider, setup.indexerProvider, setup.serverPubKey, setup.offchainTapscript, setup.boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, setup.dustAmount, setup.walletRepository, setup.contractRepository, config.renewalConfig);
+        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);
     }
     /**
      * Convert this wallet to a readonly wallet.
@@ -479,7 +722,7 @@ export class Wallet extends ReadonlyWallet {
         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);
+        return new ReadonlyWallet(readonlyIdentity, this.network, this.onchainProvider, this.indexerProvider, this.arkServerPublicKey, this.offchainTapscript, this.boardingTapscript, this.dustAmount, this.walletRepository, this.contractRepository, this.delegatorProvider, this.watcherConfig);
     }
     async sendBitcoin(params) {
         if (params.amount <= 0) {
@@ -488,12 +731,7 @@ export class Wallet extends ReadonlyWallet {
         if (!isValidArkAddress(params.address)) {
             throw new Error("Invalid Ark address " + params.address);
         }
-        // recoverable and subdust coins can't be spent in offchain tx
-        const virtualCoins = await this.getVirtualCoins({
-            withRecoverable: false,
-        });
-        let selected;
-        if (params.selectedVtxos) {
+        if (params.selectedVtxos && params.selectedVtxos.length > 0) {
             const selectedVtxoSum = params.selectedVtxos
                 .map((v) => v.value)
                 .reduce((a, b) => a + b, 0);
@@ -501,125 +739,38 @@ export class Wallet extends ReadonlyWallet {
                 throw new Error("Selected VTXOs do not cover specified amount");
             }
             const changeAmount = selectedVtxoSum - params.amount;
-            selected = {
+            const 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");
-        }
-        const outputAddress = ArkAddress.decode(params.address);
-        const outputScript = BigInt(params.amount) < this.dustAmount
-            ? outputAddress.subdustPkScript
-            : outputAddress.pkScript;
-        const outputs = [
-            {
-                script: outputScript,
-                amount: BigInt(params.amount),
-            },
-        ];
-        // add change output if needed
-        if (selected.changeAmount > 0n) {
-            const changeOutputScript = selected.changeAmount < this.dustAmount
-                ? this.arkAddress.subdustPkScript
-                : this.arkAddress.pkScript;
-            outputs.push({
-                script: changeOutputScript,
-                amount: BigInt(selected.changeAmount),
-            });
-        }
-        const tapTree = this.offchainTapscript.encode();
-        const offchainTx = buildOffchainTx(selected.inputs.map((input) => ({
-            ...input,
-            tapLeafScript: selectedLeaf,
-            tapTree,
-        })), outputs, this.serverUnrollScript);
-        const signedVirtualTx = await this.identity.sign(offchainTx.arkTx);
-        const { arkTxid, signedCheckpointTxs } = await this.arkProvider.submitTx(base64.encode(signedVirtualTx.toPSBT()), offchainTx.checkpoints.map((c) => base64.encode(c.toPSBT())));
-        // sign the checkpoints
-        const finalCheckpoints = await Promise.all(signedCheckpointTxs.map(async (c) => {
-            const tx = Transaction.fromPSBT(base64.decode(c));
-            const signedCheckpoint = await this.identity.sign(tx);
-            return base64.encode(signedCheckpoint.toPSBT());
-        }));
-        await this.arkProvider.finalizeTx(arkTxid, finalCheckpoints);
-        try {
-            // mark VTXOs as spent and optionally add the change VTXO
-            const spentVtxos = [];
-            const commitmentTxIds = new Set();
-            let batchExpiry = Number.MAX_SAFE_INTEGER;
-            for (const [inputIndex, input] of selected.inputs.entries()) {
-                const vtxo = extendVirtualCoin(this, input);
-                const checkpointB64 = signedCheckpointTxs[inputIndex];
-                const checkpoint = Transaction.fromPSBT(base64.decode(checkpointB64));
-                spentVtxos.push({
-                    ...vtxo,
-                    virtualStatus: { ...vtxo.virtualStatus, state: "spent" },
-                    spentBy: checkpoint.id,
-                    arkTxId: arkTxid,
-                    isSpent: true,
-                });
-                if (vtxo.virtualStatus.commitmentTxIds) {
-                    for (const commitmentTxId of vtxo.virtualStatus
-                        .commitmentTxIds) {
-                        commitmentTxIds.add(commitmentTxId);
-                    }
-                }
-                if (vtxo.virtualStatus.batchExpiry) {
-                    batchExpiry = Math.min(batchExpiry, vtxo.virtualStatus.batchExpiry);
-                }
-            }
-            const createdAt = Date.now();
-            const addr = this.arkAddress.encode();
-            if (selected.changeAmount > 0n &&
-                batchExpiry !== Number.MAX_SAFE_INTEGER) {
-                const changeVtxo = {
-                    txid: arkTxid,
-                    vout: outputs.length - 1,
-                    createdAt: new Date(createdAt),
-                    forfeitTapLeafScript: this.offchainTapscript.forfeit(),
-                    intentTapLeafScript: this.offchainTapscript.forfeit(),
-                    isUnrolled: false,
-                    isSpent: false,
-                    tapTree: this.offchainTapscript.encode(),
-                    value: Number(selected.changeAmount),
-                    virtualStatus: {
-                        state: "preconfirmed",
-                        commitmentTxIds: Array.from(commitmentTxIds),
-                        batchExpiry,
-                    },
-                    status: {
-                        confirmed: false,
-                    },
-                };
-                await this.walletRepository.saveVtxos(addr, [changeVtxo]);
-            }
-            await this.walletRepository.saveVtxos(addr, spentVtxos);
-            await this.walletRepository.saveTransactions(addr, [
+            const outputAddress = ArkAddress.decode(params.address);
+            const outputScript = BigInt(params.amount) < this.dustAmount
+                ? outputAddress.subdustPkScript
+                : outputAddress.pkScript;
+            const outputs = [
                 {
-                    key: {
-                        boardingTxid: "",
-                        commitmentTxid: "",
-                        arkTxid: arkTxid,
-                    },
-                    amount: params.amount,
-                    type: TxType.TxSent,
-                    settled: false,
-                    createdAt: Date.now(),
+                    script: outputScript,
+                    amount: BigInt(params.amount),
                 },
-            ]);
-        }
-        catch (e) {
-            console.warn("error saving offchain tx to repository", e);
-        }
-        finally {
+            ];
+            // add change output if needed
+            if (selected.changeAmount > 0n) {
+                const changeOutputScript = selected.changeAmount < this.dustAmount
+                    ? this.arkAddress.subdustPkScript
+                    : this.arkAddress.pkScript;
+                outputs.push({
+                    script: changeOutputScript,
+                    amount: BigInt(selected.changeAmount),
+                });
+            }
+            const { arkTxid, signedCheckpointTxs } = await this.buildAndSubmitOffchainTx(selected.inputs, outputs);
+            await this.updateDbAfterOffchainTx(selected.inputs, arkTxid, signedCheckpointTxs, params.amount, selected.changeAmount, selected.changeAmount > 0n ? outputs.length - 1 : 0);
             return arkTxid;
         }
+        return this.send({
+            address: params.address,
+            amount: params.amount,
+        });
     }
     async settle(params, eventCallback) {
         if (params?.inputs) {
@@ -720,6 +871,49 @@ export class Wallet extends ReadonlyWallet {
                 script,
             });
         }
+        // if some of the inputs hold assets, build the asset packet and append as output
+        // in the intent proof tx, there is a "fake" input at index 0
+        // so the real coin indices are offset by +1
+        const assetInputs = new Map();
+        for (let i = 0; i < params.inputs.length; i++) {
+            if ("assets" in params.inputs[i]) {
+                const assets = params.inputs[i]
+                    .assets;
+                if (assets && assets.length > 0) {
+                    assetInputs.set(i + 1, assets);
+                }
+            }
+        }
+        let outputAssets;
+        let assetOutputIndex; // where to send the assets
+        if (assetInputs.size > 0) {
+            // collect all input assets and assign them to the first offchain output
+            const allAssets = new Map();
+            for (const [, assets] of assetInputs) {
+                for (const asset of assets) {
+                    const existing = allAssets.get(asset.assetId) ?? 0n;
+                    allAssets.set(asset.assetId, existing + BigInt(asset.amount));
+                }
+            }
+            outputAssets = [];
+            for (const [assetId, amount] of allAssets) {
+                outputAssets.push({ assetId, amount: Number(amount) });
+            }
+            const firstOffchainIndex = params.outputs.findIndex((_, i) => !onchainOutputIndexes.includes(i));
+            if (firstOffchainIndex === -1) {
+                throw new Error("Cannot settle assets without an offchain output");
+            }
+            assetOutputIndex = firstOffchainIndex;
+        }
+        const recipients = params.outputs.map((output, i) => ({
+            address: output.address,
+            amount: Number(output.amount),
+            assets: i === assetOutputIndex ? outputAssets : undefined,
+        }));
+        if (outputAssets && outputAssets.length > 0) {
+            const assetPacket = createAssetPacket(assetInputs, recipients);
+            outputs.push(assetPacket.txOut());
+        }
         // session holds the state of the musig2 signing process of the vtxo tree
         let session;
         const signingPublicKeys = [];
@@ -736,17 +930,19 @@ export class Wallet extends ReadonlyWallet {
             ...signingPublicKeys,
             ...params.inputs.map((input) => `${input.txid}:${input.vout}`),
         ];
-        const handler = this.createBatchHandler(intentId, params.inputs, session);
+        const handler = this.createBatchHandler(intentId, params.inputs, recipients, session);
         const abortController = new AbortController();
         try {
             const stream = this.arkProvider.getEventStream(abortController.signal, topics);
-            return await Batch.join(stream, handler, {
+            const commitmentTxid = await Batch.join(stream, handler, {
                 abortController,
                 skipVtxoTreeSigning: !hasOffchainOutputs,
                 eventCallback: eventCallback
                     ? (event) => Promise.resolve(eventCallback(event))
                     : undefined,
             });
+            await this.updateDbAfterSettle(params.inputs, commitmentTxid);
+            return commitmentTxid;
         }
         catch (error) {
             // delete the intent to not be stuck in the queue
@@ -851,8 +1047,9 @@ export class Wallet extends ReadonlyWallet {
      * @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.
+     * @param expectedRecipients - Expected recipients to validate in the vtxo tree.
      */
-    createBatchHandler(intentId, inputs, session) {
+    createBatchHandler(intentId, inputs, expectedRecipients, session) {
         let sweepTapTreeRoot;
         return {
             onBatchStarted: async (event) => {
@@ -900,7 +1097,10 @@ export class Wallet extends ReadonlyWallet {
                 // validate the unsigned vtxo tree
                 const commitmentTx = Transaction.fromPSBT(base64.decode(event.unsignedCommitmentTx));
                 validateVtxoTxGraph(vtxoTree, commitmentTx, sweepTapTreeRoot);
-                // TODO check if our registered outputs are in the vtxo tree
+                // validate that all expected receivers are in the vtxo tree with correct amounts and assets
+                if (expectedRecipients && expectedRecipients.length > 0) {
+                    validateBatchRecipients(commitmentTx, vtxoTree.leaves(), expectedRecipients, this.network);
+                }
                 const sharedOutput = commitmentTx.getOutput(0);
                 if (!sharedOutput?.amount) {
                     throw new Error("Shared output not found");
@@ -956,16 +1156,15 @@ export class Wallet extends ReadonlyWallet {
             throw error;
         }
     }
-    async makeRegisterIntentSignature(coins, outputs, onchainOutputsIndexes, cosignerPubKeys) {
-        const inputs = this.prepareIntentProofInputs(coins);
+    async makeRegisterIntentSignature(coins, outputs, onchainOutputsIndexes, cosignerPubKeys, validAt) {
         const message = {
             type: "register",
             onchain_output_indexes: onchainOutputsIndexes,
-            valid_at: 0,
+            valid_at: validAt ? Math.floor(validAt) : 0,
             expire_at: 0,
             cosigners_public_keys: cosignerPubKeys,
         };
-        const proof = Intent.create(message, inputs, outputs);
+        const proof = Intent.create(message, coins, outputs);
         const signedProof = await this.identity.sign(proof);
         return {
             proof: base64.encode(signedProof.toPSBT()),
@@ -973,25 +1172,23 @@ export class Wallet extends ReadonlyWallet {
         };
     }
     async makeDeleteIntentSignature(coins) {
-        const inputs = this.prepareIntentProofInputs(coins);
         const message = {
             type: "delete",
             expire_at: 0,
         };
-        const proof = Intent.create(message, inputs, []);
+        const proof = Intent.create(message, coins, []);
         const signedProof = await this.identity.sign(proof);
         return {
             proof: base64.encode(signedProof.toPSBT()),
             message,
         };
     }
-    async makeGetPendingTxIntentSignature(vtxos) {
-        const inputs = this.prepareIntentProofInputs(vtxos);
+    async makeGetPendingTxIntentSignature(coins) {
         const message = {
             type: "get-pending-tx",
             expire_at: 0,
         };
-        const proof = Intent.create(message, inputs, []);
+        const proof = Intent.create(message, coins, []);
         const signedProof = await this.identity.sign(proof);
         return {
             proof: base64.encode(signedProof.toPSBT()),
@@ -1006,17 +1203,28 @@ export class Wallet extends ReadonlyWallet {
     async finalizePendingTxs(vtxos) {
         const MAX_INPUTS_PER_INTENT = 20;
         if (!vtxos || vtxos.length === 0) {
-            // get non-swept VTXOs, rely on the indexer only in case DB doesn't have the right state
-            const scripts = [hex.encode(this.offchainTapscript.pkScript)];
-            let { vtxos: fetchedVtxos } = await this.indexerProvider.getVtxos({
-                scripts,
-            });
-            fetchedVtxos = fetchedVtxos.filter((vtxo) => vtxo.virtualStatus.state !== "swept" &&
-                vtxo.virtualStatus.state !== "settled");
-            if (fetchedVtxos.length === 0) {
+            // Query per-script so each VTXO is extended with the correct tapscript
+            const scriptMap = await this.getScriptMap();
+            const allExtended = [];
+            for (const [scriptHex, vtxoScript] of scriptMap) {
+                const { vtxos: fetchedVtxos } = await this.indexerProvider.getVtxos({
+                    scripts: [scriptHex],
+                });
+                const pending = fetchedVtxos.filter((vtxo) => vtxo.virtualStatus.state !== "swept" &&
+                    vtxo.virtualStatus.state !== "settled");
+                for (const vtxo of pending) {
+                    allExtended.push({
+                        ...vtxo,
+                        forfeitTapLeafScript: vtxoScript.forfeit(),
+                        intentTapLeafScript: vtxoScript.forfeit(),
+                        tapTree: vtxoScript.encode(),
+                    });
+                }
+            }
+            if (allExtended.length === 0) {
                 return { finalized: [], pending: [] };
             }
-            vtxos = fetchedVtxos.map((v) => extendVirtualCoin(this, v));
+            vtxos = allExtended;
         }
         const finalized = [];
         const pending = [];
@@ -1045,66 +1253,333 @@ export class Wallet extends ReadonlyWallet {
         }
         return { finalized, pending };
     }
-    prepareIntentProofInputs(coins) {
-        const inputs = [];
-        for (const input of coins) {
-            const vtxoScript = VtxoScript.decode(input.tapTree);
-            const sequence = getSequence(input.intentTapLeafScript);
-            const unknown = [VtxoTaprootTree.encode(input.tapTree)];
-            if (input.extraWitness) {
-                unknown.push(ConditionWitness.encode(input.extraWitness));
+    /**
+     * Send BTC and/or assets to one or more recipients.
+     *
+     * @param recipients - Array of recipients with their addresses, BTC amounts, and assets
+     * @returns Promise resolving to the ark transaction ID
+     *
+     * @example
+     * ```typescript
+     * const txid = await wallet.send({
+     *     address: 'ark1...',
+     *     amount: 1000, // (optional, default to dust) btc amount to send to the output
+     *     assets: [{ assetId: 'abc123...', amount: 50 }] // (optional) list of assets to send
+     * });
+     * ```
+     */
+    async send(...args) {
+        if (args.length === 0) {
+            throw new Error("At least one receiver is required");
+        }
+        // validate recipients and populate undefined amount with dust amount
+        const recipients = validateRecipients(args, Number(this.dustAmount));
+        const address = await this.getAddress();
+        const outputAddress = ArkAddress.decode(address);
+        const virtualCoins = await this.getVirtualCoins({
+            withRecoverable: false,
+        });
+        // keep track of asset changes
+        const assetChanges = new Map();
+        let selectedCoins = [];
+        let btcAmountToSelect = 0;
+        for (const recipient of recipients) {
+            btcAmountToSelect += Math.max(recipient.amount, Number(this.dustAmount));
+        }
+        // select assets
+        for (const recipient of recipients) {
+            if (!recipient.assets) {
+                continue;
             }
-            inputs.push({
-                txid: hex.decode(input.txid),
-                index: input.vout,
-                witnessUtxo: {
-                    amount: BigInt(input.value),
-                    script: vtxoScript.pkScript,
-                },
-                sequence,
-                tapLeafScript: [input.intentTapLeafScript],
-                unknown,
+            for (const receiverAsset of recipient.assets) {
+                let amountToSelect = BigInt(receiverAsset.amount);
+                // check if existing change covers the needed amount
+                const existingChange = assetChanges.get(receiverAsset.assetId) ?? 0n;
+                if (existingChange >= amountToSelect) {
+                    assetChanges.set(receiverAsset.assetId, existingChange - amountToSelect);
+                    if (assetChanges.get(receiverAsset.assetId) === 0n) {
+                        assetChanges.delete(receiverAsset.assetId);
+                    }
+                    continue;
+                }
+                if (existingChange > 0n) {
+                    amountToSelect -= existingChange;
+                    assetChanges.delete(receiverAsset.assetId);
+                }
+                const availableCoins = virtualCoins.filter((c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout));
+                const { selected, totalAssetAmount } = selectCoinsWithAsset(availableCoins, receiverAsset.assetId, amountToSelect);
+                for (const coin of selected) {
+                    selectedCoins.push(coin);
+                    // asset coins contain btc, subtract from total amount to select
+                    btcAmountToSelect -= coin.value;
+                    // coin may contain other assets, add them to asset changes
+                    if (coin.assets) {
+                        for (const a of coin.assets) {
+                            if (a.assetId === receiverAsset.assetId) {
+                                continue;
+                            }
+                            const existing = assetChanges.get(a.assetId) ?? 0n;
+                            assetChanges.set(a.assetId, existing + BigInt(a.amount));
+                        }
+                    }
+                }
+                const assetChangeAmount = totalAssetAmount - amountToSelect;
+                if (assetChangeAmount > 0n) {
+                    const existing = assetChanges.get(receiverAsset.assetId) ?? 0n;
+                    assetChanges.set(receiverAsset.assetId, existing + assetChangeAmount);
+                }
+            }
+        }
+        // select remaining btc
+        if (btcAmountToSelect > 0) {
+            const availableCoins = virtualCoins.filter((c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout));
+            const { inputs: btcCoins } = selectVirtualCoins(availableCoins, btcAmountToSelect);
+            // some coins may contain assets, add them to asset changes
+            for (const coin of btcCoins) {
+                if (coin.assets) {
+                    for (const asset of coin.assets) {
+                        const existing = assetChanges.get(asset.assetId) ?? 0n;
+                        assetChanges.set(asset.assetId, existing + BigInt(asset.amount));
+                    }
+                }
+            }
+            selectedCoins = [...selectedCoins, ...btcCoins];
+        }
+        let totalBtcSelected = selectedCoins.reduce((sum, c) => sum + c.value, 0);
+        // build tx outputs
+        const outputs = recipients.map((recipient) => ({
+            script: recipient.script,
+            amount: BigInt(recipient.amount),
+        }));
+        const totalBtcOutput = outputs.reduce((sum, o) => sum + Number(o.amount), 0);
+        let changeAmount = totalBtcSelected - totalBtcOutput;
+        // enforce minimum change amount when there are asset changes
+        if (assetChanges.size > 0 && changeAmount < Number(this.dustAmount)) {
+            const availableCoins = virtualCoins.filter((c) => !selectedCoins.find((sc) => sc.txid === c.txid && sc.vout === c.vout));
+            const { inputs: extraCoins } = selectVirtualCoins(availableCoins, Number(this.dustAmount) - changeAmount);
+            for (const coin of extraCoins) {
+                if (coin.assets) {
+                    for (const asset of coin.assets) {
+                        const existing = assetChanges.get(asset.assetId) ?? 0n;
+                        assetChanges.set(asset.assetId, existing + BigInt(asset.amount));
+                    }
+                }
+            }
+            selectedCoins = [...selectedCoins, ...extraCoins];
+            totalBtcSelected += extraCoins.reduce((sum, c) => sum + c.value, 0);
+            changeAmount = totalBtcSelected - totalBtcOutput;
+        }
+        // build change receiver with BTC change and all asset changes
+        let changeReceiver;
+        let changeIndex = 0;
+        if (changeAmount > 0) {
+            const changeAssets = [];
+            for (const [assetId, amount] of assetChanges) {
+                if (amount > 0n) {
+                    changeAssets.push({ assetId, amount: Number(amount) });
+                }
+            }
+            changeIndex = outputs.length;
+            outputs.push({
+                script: BigInt(changeAmount) < this.dustAmount
+                    ? outputAddress.subdustPkScript
+                    : outputAddress.pkScript,
+                amount: BigInt(changeAmount),
             });
+            changeReceiver = {
+                address: address,
+                amount: changeAmount,
+                assets: changeAssets.length > 0 ? changeAssets : undefined,
+            };
+        }
+        // create asset packet only if there are assets involved
+        const assetInputs = selectedCoinsToAssetInputs(selectedCoins);
+        const hasAssets = assetInputs.size > 0 ||
+            recipients.some((r) => r.assets && r.assets.length > 0);
+        if (hasAssets) {
+            const assetPacket = createAssetPacket(assetInputs, recipients, changeReceiver);
+            outputs.push(assetPacket.txOut());
         }
-        return inputs;
+        const sentAmount = recipients.reduce((sum, r) => sum + r.amount, 0);
+        const { arkTxid, signedCheckpointTxs } = await this.buildAndSubmitOffchainTx(selectedCoins, outputs);
+        await this.updateDbAfterOffchainTx(selectedCoins, arkTxid, signedCheckpointTxs, sentAmount, BigInt(changeAmount), changeReceiver ? changeIndex : 0, changeReceiver?.assets);
+        return arkTxid;
     }
-}
-Wallet.MIN_FEE_RATE = 1; // sats/vbyte
-export function getSequence(tapLeafScript) {
-    let sequence = undefined;
-    try {
-        const scriptWithLeafVersion = tapLeafScript[1];
-        const script = scriptWithLeafVersion.subarray(0, scriptWithLeafVersion.length - 1);
+    /**
+     * Build an offchain transaction from the given inputs and outputs,
+     * sign it, submit to the ark provider, and finalize.
+     * @returns The ark transaction id and server-signed checkpoint PSBTs (for bookkeeping)
+     */
+    async buildAndSubmitOffchainTx(inputs, outputs) {
+        const tapLeafScript = this.offchainTapscript.forfeit();
+        if (!tapLeafScript) {
+            throw new Error("Selected leaf not found");
+        }
+        const tapTree = this.offchainTapscript.encode();
+        const offchainTx = buildOffchainTx(inputs.map((input) => ({
+            ...input,
+            tapLeafScript,
+            tapTree,
+        })), outputs, this.serverUnrollScript);
+        const signedVirtualTx = await this.identity.sign(offchainTx.arkTx);
+        const { arkTxid, signedCheckpointTxs } = await this.arkProvider.submitTx(base64.encode(signedVirtualTx.toPSBT()), offchainTx.checkpoints.map((c) => base64.encode(c.toPSBT())));
+        const finalCheckpoints = await Promise.all(signedCheckpointTxs.map(async (c) => {
+            const tx = Transaction.fromPSBT(base64.decode(c));
+            const signedCheckpoint = await this.identity.sign(tx);
+            return base64.encode(signedCheckpoint.toPSBT());
+        }));
+        await this.arkProvider.finalizeTx(arkTxid, finalCheckpoints);
+        return { arkTxid, signedCheckpointTxs };
+    }
+    // mark vtxo spent and save change vtxo if any
+    async updateDbAfterOffchainTx(inputs, arkTxid, signedCheckpointTxs, sentAmount, changeAmount, changeVout, changeAssets) {
         try {
-            const params = CSVMultisigTapscript.decode(script).params;
-            sequence = bip68.encode(params.timelock.type === "blocks"
-                ? { blocks: Number(params.timelock.value) }
-                : { seconds: Number(params.timelock.value) });
+            const spentVtxos = [];
+            const commitmentTxIds = new Set();
+            let batchExpiry = Number.MAX_SAFE_INTEGER;
+            if (inputs.length !== signedCheckpointTxs.length) {
+                console.warn(`updateDbAfterOffchainTx: inputs length (${inputs.length}) differs from signedCheckpointTxs length (${signedCheckpointTxs.length})`);
+            }
+            const safeLength = Math.min(inputs.length, signedCheckpointTxs.length);
+            for (const [inputIndex, input] of inputs.entries()) {
+                const vtxo = extendVirtualCoin(this, input);
+                if (inputIndex < safeLength &&
+                    signedCheckpointTxs[inputIndex]) {
+                    const checkpoint = Transaction.fromPSBT(base64.decode(signedCheckpointTxs[inputIndex]));
+                    spentVtxos.push({
+                        ...vtxo,
+                        virtualStatus: {
+                            ...vtxo.virtualStatus,
+                            state: "spent",
+                        },
+                        spentBy: checkpoint.id,
+                        arkTxId: arkTxid,
+                        isSpent: true,
+                    });
+                }
+                else {
+                    spentVtxos.push({
+                        ...vtxo,
+                        virtualStatus: {
+                            ...vtxo.virtualStatus,
+                            state: "spent",
+                        },
+                        arkTxId: arkTxid,
+                        isSpent: true,
+                    });
+                }
+                if (vtxo.virtualStatus.commitmentTxIds) {
+                    for (const id of vtxo.virtualStatus.commitmentTxIds) {
+                        commitmentTxIds.add(id);
+                    }
+                }
+                if (vtxo.virtualStatus.batchExpiry) {
+                    batchExpiry = Math.min(batchExpiry, vtxo.virtualStatus.batchExpiry);
+                }
+            }
+            const createdAt = Date.now();
+            const addr = this.arkAddress.encode();
+            // Only save a change VTXO for preconfirmed coins (those with a batchExpiry).
+            // Inputs without a batchExpiry are already settled/unrolled and don't need tracking.
+            let changeVtxo;
+            if (changeAmount > 0n && batchExpiry !== Number.MAX_SAFE_INTEGER) {
+                changeVtxo = {
+                    txid: arkTxid,
+                    vout: changeVout,
+                    createdAt: new Date(createdAt),
+                    forfeitTapLeafScript: this.offchainTapscript.forfeit(),
+                    intentTapLeafScript: this.offchainTapscript.forfeit(),
+                    isUnrolled: false,
+                    isSpent: false,
+                    tapTree: this.offchainTapscript.encode(),
+                    value: Number(changeAmount),
+                    virtualStatus: {
+                        state: "preconfirmed",
+                        commitmentTxIds: Array.from(commitmentTxIds),
+                        batchExpiry,
+                    },
+                    status: {
+                        confirmed: false,
+                    },
+                    assets: changeAssets,
+                };
+            }
+            await this.walletRepository.saveVtxos(addr, changeVtxo ? [...spentVtxos, changeVtxo] : spentVtxos);
+            await this.walletRepository.saveTransactions(addr, [
+                {
+                    key: {
+                        boardingTxid: "",
+                        commitmentTxid: "",
+                        arkTxid: arkTxid,
+                    },
+                    amount: sentAmount,
+                    type: TxType.TxSent,
+                    settled: false,
+                    createdAt,
+                },
+            ]);
         }
-        catch {
-            const params = CLTVMultisigTapscript.decode(script).params;
-            sequence = Number(params.absoluteTimelock);
+        catch (e) {
+            console.warn("error saving offchain tx to repository", e);
         }
     }
-    catch { }
-    return sequence;
-}
-function isValidArkAddress(address) {
-    try {
-        ArkAddress.decode(address);
-        return true;
-    }
-    catch (e) {
-        return false;
+    // mark vtxo spent & settled, remove boarding utxo
+    async updateDbAfterSettle(inputs, commitmentTxid) {
+        try {
+            const addr = this.arkAddress.encode();
+            const boardingAddress = await this.getBoardingAddress();
+            const spentVtxos = [];
+            const inputArkTxIds = new Set();
+            const boardingUtxoToRemove = new Set();
+            const isVtxo = (input) => "virtualStatus" in input;
+            for (const input of inputs) {
+                if (isVtxo(input)) {
+                    // vtxo = mark it settled
+                    const vtxo = extendVirtualCoin(this, input);
+                    if (vtxo.arkTxId) {
+                        inputArkTxIds.add(vtxo.arkTxId);
+                    }
+                    spentVtxos.push({
+                        ...vtxo,
+                        virtualStatus: {
+                            ...vtxo.virtualStatus,
+                            state: "settled",
+                        },
+                        settledBy: commitmentTxid,
+                        isSpent: true,
+                    });
+                }
+                else {
+                    // boarding utxo = remove it
+                    boardingUtxoToRemove.add(`${input.txid}:${input.vout}`);
+                }
+            }
+            if (spentVtxos.length > 0) {
+                await this.walletRepository.saveVtxos(addr, spentVtxos);
+            }
+            if (boardingUtxoToRemove.size > 0) {
+                const currentUtxos = await this.walletRepository.getUtxos(boardingAddress);
+                const filtered = currentUtxos.filter((u) => !boardingUtxoToRemove.has(`${u.txid}:${u.vout}`));
+                // Clear and re-save the filtered list
+                await this.walletRepository.deleteUtxos(boardingAddress);
+                if (filtered.length > 0) {
+                    await this.walletRepository.saveUtxos(boardingAddress, filtered);
+                }
+            }
+        }
+        catch (e) {
+            console.warn("error updating repository after settle", e);
+        }
     }
 }
+Wallet.MIN_FEE_RATE = 1; // sats/vbyte
 /**
  * Select virtual coins to reach a target amount, prioritizing those closer to expiry
  * @param coins List of virtual coins to select from
  * @param targetAmount Target amount to reach in satoshis
  * @returns Selected coins and change amount
  */
-function selectVirtualCoins(coins, targetAmount) {
+export function selectVirtualCoins(coins, targetAmount) {
     // Sort VTXOs by expiry (ascending) and amount (descending)
     const sortedCoins = [...coins].sort((a, b) => {
         // First sort by expiry if available