@arkade-os/sdk 0.3.9 → 0.3.11

package/dist/esm/utils/transactionHistory.js

@@ -1,165 +1,127 @@
 import { TxType } from '../wallet/index.js';
+const txKey = {
+    commitmentTxid: "",
+    boardingTxid: "",
+    arkTxid: "",
+};
 /**
- * @param spendable - Vtxos that are spendable
- * @param spent - Vtxos that are spent
- * @param boardingBatchTxids - Set of boarding batch txids
- * @returns Ark transactions
+ * Builds the transaction history by analyzing virtual coins (VTXOs), boarding transactions, and ignored commitments.
+ * History is sorted from newest to oldest and is composed only of SENT and RECEIVED transactions.
+ *
+ * @param {VirtualCoin[]} vtxos - An array of virtual coins representing the user's transactions and balances.
+ * @param {ArkTransaction[]} allBoardingTxs - An array of boarding transactions to include in the history.
+ * @param {Set<string>} commitmentsToIgnore - A set of commitment IDs that should be excluded from processing.
+ * @return {ExtendedArkTransaction[]} A sorted array of extended Ark transactions, representing the transaction history.
  */
-export function vtxosToTxs(spendable, spent, boardingBatchTxids) {
-    const txs = [];
-    // Receive case
-    // All vtxos are received unless:
-    // - they resulted from a settlement (either boarding or refresh)
-    // - they are the change of a spend tx
-    let vtxosLeftToCheck = [...spent];
-    for (const vtxo of [...spendable, ...spent]) {
-        if (vtxo.virtualStatus.state !== "preconfirmed" &&
-            vtxo.virtualStatus.commitmentTxIds &&
-            vtxo.virtualStatus.commitmentTxIds.some((txid) => boardingBatchTxids.has(txid))) {
-            continue;
-        }
-        const settleVtxos = findVtxosSpentInSettlement(vtxosLeftToCheck, vtxo);
-        vtxosLeftToCheck = removeVtxosFromList(vtxosLeftToCheck, settleVtxos);
-        const settleAmount = reduceVtxosAmount(settleVtxos);
-        if (vtxo.value <= settleAmount) {
-            continue; // settlement or change, ignore
-        }
-        const spentVtxos = findVtxosSpentInPayment(vtxosLeftToCheck, vtxo);
-        vtxosLeftToCheck = removeVtxosFromList(vtxosLeftToCheck, spentVtxos);
-        const spentAmount = reduceVtxosAmount(spentVtxos);
-        if (vtxo.value <= spentAmount) {
-            continue; // settlement or change, ignore
-        }
-        const txKey = {
-            commitmentTxid: "",
-            boardingTxid: "",
-            arkTxid: "",
-        };
-        let settled = vtxo.virtualStatus.state !== "preconfirmed";
-        if (vtxo.virtualStatus.state === "preconfirmed") {
-            txKey.arkTxid = vtxo.txid;
-            if (vtxo.spentBy) {
-                settled = true;
+export function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnore) {
+    const fromOldestVtxo = [...vtxos].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    const sent = [];
+    let received = [];
+    for (const vtxo of fromOldestVtxo) {
+        if (vtxo.status.isLeaf) {
+            // If this vtxo is a leaf and it's not the settlement of a boarding or there's no vtxo refreshed by it,
+            // it's translated into a received batch transaction
+            if (!commitmentsToIgnore.has(vtxo.virtualStatus.commitmentTxIds[0]) &&
+                fromOldestVtxo.filter((v) => v.settledBy === vtxo.virtualStatus.commitmentTxIds[0]).length === 0) {
+                received.push({
+                    key: {
+                        ...txKey,
+                        commitmentTxid: vtxo.virtualStatus.commitmentTxIds[0],
+                    },
+                    tag: "batch",
+                    type: TxType.TxReceived,
+                    amount: vtxo.value,
+                    settled: vtxo.status.isLeaf || vtxo.isSpent,
+                    createdAt: vtxo.createdAt.getTime(),
+                });
             }
         }
-        else {
-            txKey.commitmentTxid =
-                vtxo.virtualStatus.commitmentTxIds?.[0] || "";
+        else if (fromOldestVtxo.filter((v) => v.arkTxId === vtxo.txid).length === 0) {
+            // If this vtxo is preconfirmed and does not spend any other vtxos,
+            // it's translated into a received offchain transaction
+            received.push({
+                key: { ...txKey, arkTxid: vtxo.txid },
+                tag: "offchain",
+                type: TxType.TxReceived,
+                amount: vtxo.value,
+                settled: vtxo.status.isLeaf || vtxo.isSpent,
+                createdAt: vtxo.createdAt.getTime(),
+            });
         }
-        txs.push({
-            key: txKey,
-            amount: vtxo.value - settleAmount - spentAmount,
-            type: TxType.TxReceived,
-            createdAt: vtxo.createdAt.getTime(),
-            settled,
-        });
-    }
-    // vtxos by settled by or ark txid
-    const vtxosByTxid = new Map();
-    for (const v of spent) {
-        if (v.settledBy) {
-            if (!vtxosByTxid.has(v.settledBy)) {
-                vtxosByTxid.set(v.settledBy, []);
+        // If the vtxo is spent, it's translated into a sent transaction unless:
+        // - it's been refreshed (we don't want to add any record in this case)
+        // - a sent transaction has been already added to avoid duplicates (can happen if many vtxos have been spent in the same tx or forfeited in the same batch)
+        if (vtxo.isSpent) {
+            // If the vtxo is spent offchain, it's translated into offchain sent tx
+            if (vtxo.arkTxId &&
+                !sent.some((s) => s.key.arkTxid === vtxo.arkTxId)) {
+                const changes = fromOldestVtxo.filter((_) => _.txid === vtxo.arkTxId);
+                let txAmount = 0;
+                let txTime = 0;
+                if (changes.length > 0) {
+                    const changeAmount = changes.reduce((acc, v) => acc + v.value, 0);
+                    // We want to find all the other VTXOs spent by the same transaction to
+                    // calculate the full amount of the change.
+                    const allSpent = fromOldestVtxo.filter((v) => v.arkTxId === vtxo.arkTxId);
+                    const spentAmount = allSpent.reduce((acc, v) => acc + v.value, 0);
+                    txAmount = spentAmount - changeAmount;
+                    txTime = changes[0].createdAt.getTime();
+                }
+                else {
+                    txAmount = vtxo.value;
+                    // TODO: fetch the vtxo with /v1/indexer/vtxos?outpoints=<vtxo.arkTxid:0> to know when the tx was made
+                    txTime = vtxo.createdAt.getTime() + 1;
+                }
+                sent.push({
+                    key: { ...txKey, arkTxid: vtxo.arkTxId },
+                    tag: "offchain",
+                    type: TxType.TxSent,
+                    amount: txAmount,
+                    settled: true,
+                    createdAt: txTime,
+                });
             }
-            const currentVtxos = vtxosByTxid.get(v.settledBy);
-            vtxosByTxid.set(v.settledBy, [...currentVtxos, v]);
-        }
-        if (!v.arkTxId) {
-            continue;
-        }
-        if (!vtxosByTxid.has(v.arkTxId)) {
-            vtxosByTxid.set(v.arkTxId, []);
-        }
-        const currentVtxos = vtxosByTxid.get(v.arkTxId);
-        vtxosByTxid.set(v.arkTxId, [...currentVtxos, v]);
-    }
-    for (const [sb, vtxos] of vtxosByTxid) {
-        const resultedVtxos = findVtxosResultedFromTxid([...spendable, ...spent], sb);
-        const resultedAmount = reduceVtxosAmount(resultedVtxos);
-        const spentAmount = reduceVtxosAmount(vtxos);
-        if (spentAmount <= resultedAmount) {
-            continue; // settlement or change, ignore
-        }
-        const vtxo = getVtxo(resultedVtxos, vtxos);
-        const txKey = {
-            commitmentTxid: "",
-            boardingTxid: "",
-            arkTxid: "",
-        };
-        if (vtxo.virtualStatus.state === "preconfirmed") {
-            txKey.arkTxid = resultedAmount === 0 ? vtxo.arkTxId : vtxo.txid;
-        }
-        else {
-            txKey.commitmentTxid =
-                vtxo.virtualStatus.commitmentTxIds?.[0] || "";
-        }
-        txs.push({
-            key: txKey,
-            amount: spentAmount - resultedAmount,
-            type: TxType.TxSent,
-            createdAt: vtxo.createdAt.getTime(),
-            settled: true,
-        });
-    }
-    return txs;
-}
-/**
- * Helper function to find vtxos that were spent in a settlement
- */
-function findVtxosSpentInSettlement(vtxos, vtxo) {
-    if (vtxo.virtualStatus.state === "preconfirmed") {
-        return [];
-    }
-    return vtxos.filter((v) => {
-        if (!v.settledBy)
-            return false;
-        return (vtxo.virtualStatus.commitmentTxIds?.includes(v.settledBy) ?? false);
-    });
-}
-/**
- * Helper function to find vtxos that were spent in a payment
- */
-function findVtxosSpentInPayment(vtxos, vtxo) {
-    return vtxos.filter((v) => {
-        if (!v.arkTxId)
-            return false;
-        return v.arkTxId === vtxo.txid;
-    });
-}
-/**
- * Helper function to find vtxos that resulted from a spentBy transaction
- */
-function findVtxosResultedFromTxid(vtxos, txid) {
-    return vtxos.filter((v) => {
-        if (v.virtualStatus.state !== "preconfirmed" &&
-            v.virtualStatus.commitmentTxIds?.includes(txid)) {
-            return true;
-        }
-        return v.txid === txid;
-    });
-}
-/**
- * Helper function to reduce vtxos to their total amount
- */
-function reduceVtxosAmount(vtxos) {
-    return vtxos.reduce((sum, v) => sum + v.value, 0);
-}
-/**
- * Helper function to get a vtxo from a list of vtxos
- */
-function getVtxo(resultedVtxos, spentVtxos) {
-    if (resultedVtxos.length === 0) {
-        return spentVtxos[0];
-    }
-    return resultedVtxos[0];
-}
-function removeVtxosFromList(vtxos, vtxosToRemove) {
-    return vtxos.filter((v) => {
-        for (const vtxoToRemove of vtxosToRemove) {
-            if (v.txid === vtxoToRemove.txid && v.vout === vtxoToRemove.vout) {
-                return false;
+            // If the vtxo is forfeited in a batch and the total sum of forfeited vtxos is bigger than the sum of new vtxos,
+            // it's translated into an exit sent tx
+            if (vtxo.settledBy &&
+                !commitmentsToIgnore.has(vtxo.settledBy) &&
+                !sent.some((s) => s.key.commitmentTxid === vtxo.settledBy)) {
+                const changes = fromOldestVtxo.filter((v) => v.status.isLeaf &&
+                    v.virtualStatus.commitmentTxIds?.every((_) => vtxo.settledBy === _));
+                const forfeitVtxos = fromOldestVtxo.filter((v) => v.settledBy === vtxo.settledBy);
+                const forfeitAmount = forfeitVtxos.reduce((acc, v) => acc + v.value, 0);
+                if (changes.length > 0) {
+                    const settledAmount = changes.reduce((acc, v) => acc + v.value, 0);
+                    // forfeitAmount > settledAmount --> collaborative exit with offchain change
+                    // TODO: make this support fees!
+                    if (forfeitAmount > settledAmount) {
+                        sent.push({
+                            key: { ...txKey, commitmentTxid: vtxo.settledBy },
+                            tag: "exit",
+                            type: TxType.TxSent,
+                            amount: forfeitAmount - settledAmount,
+                            settled: true,
+                            createdAt: changes[0].createdAt.getTime(),
+                        });
+                    }
+                }
+                else {
+                    // forfeitAmount > 0 && settledAmount == 0 --> collaborative exit without any offchain change
+                    sent.push({
+                        key: { ...txKey, commitmentTxid: vtxo.settledBy },
+                        tag: "exit",
+                        type: TxType.TxSent,
+                        amount: forfeitAmount,
+                        settled: true,
+                        // TODO: fetch commitment tx with /v1/indexer/commitmentTx/<commitmentTxid> to know when the tx was made
+                        createdAt: vtxo.createdAt.getTime() + 1,
+                    });
+                }
             }
         }
-        return true;
-    });
+    }
+    // Boardings are always inbound amounts, and we only hide the ones to ignore.
+    const boardingTx = allBoardingTxs.map((tx) => ({ ...tx, tag: "boarding" }));
+    const sorted = [...boardingTx, ...sent, ...received].sort((a, b) => b.createdAt - a.createdAt);
+    return sorted;
 }

package/dist/esm/wallet/ramps.js

@@ -1,3 +1,8 @@
+import { Estimator } from '../arkfee/index.js';
+import { Address, OutScript } from "@scure/btc-signer";
+import { hex } from "@scure/base";
+import { networks } from '../networks.js';
+import { ArkAddress } from '../script/address.js';
 /**
  * Ramps is a class wrapping IWallet.settle method to provide a more convenient interface for onboarding and offboarding operations.
  *
@@ -15,22 +20,51 @@ export class Ramps {
     /**
      * Onboard boarding utxos.
      *
+     * @param feeInfo - The fee info to deduct from the onboard amount.
      * @param boardingUtxos - The boarding utxos to onboard. If not provided, all boarding utxos will be used.
      * @param amount - The amount to onboard. If not provided, the total amount of boarding utxos will be onboarded.
      * @param eventCallback - The callback to receive settlement events. optional.
      */
-    async onboard(boardingUtxos, amount, eventCallback) {
+    async onboard(feeInfo, boardingUtxos, amount, eventCallback) {
         boardingUtxos = boardingUtxos ?? (await this.wallet.getBoardingUtxos());
-        const totalAmount = boardingUtxos.reduce((acc, coin) => acc + BigInt(coin.value), 0n);
+        // Calculate input fees and filter out utxos where fee >= value
+        const estimator = new Estimator(feeInfo?.intentFee ?? {});
+        const filteredBoardingUtxos = [];
+        let totalAmount = 0n;
+        for (const utxo of boardingUtxos) {
+            const inputFee = estimator.evalOnchainInput({
+                amount: BigInt(utxo.value),
+            });
+            if (inputFee.satoshis >= utxo.value) {
+                // skip if fees are greater than or equal to the utxo value
+                continue;
+            }
+            filteredBoardingUtxos.push(utxo);
+            totalAmount += BigInt(utxo.value) - BigInt(inputFee.satoshis);
+        }
+        if (filteredBoardingUtxos.length === 0) {
+            throw new Error("No boarding utxos available after deducting fees");
+        }
         let change = 0n;
         if (amount) {
             if (amount > totalAmount) {
-                throw new Error("Amount is greater than total amount of boarding utxos");
+                throw new Error("Amount is greater than total amount of boarding utxos after fees");
             }
             change = totalAmount - amount;
         }
         amount = amount ?? totalAmount;
+        // Calculate offchain output fee using Estimator
         const offchainAddress = await this.wallet.getAddress();
+        const offchainAddr = ArkAddress.decode(offchainAddress);
+        const offchainScript = hex.encode(offchainAddr.pkScript);
+        const outputFee = estimator.evalOffchainOutput({
+            amount,
+            script: offchainScript,
+        });
+        if (BigInt(outputFee.satoshis) > amount) {
+            throw new Error(`can't deduct fees from onboard amount (${outputFee.satoshis} > ${amount})`);
+        }
+        amount -= BigInt(outputFee.satoshis);
         const outputs = [
             {
                 address: offchainAddress,
@@ -45,7 +79,7 @@ export class Ramps {
             });
         }
         return this.wallet.settle({
-            inputs: boardingUtxos,
+            inputs: filteredBoardingUtxos,
             outputs,
         }, eventCallback);
     }
@@ -62,20 +96,71 @@ export class Ramps {
             withRecoverable: true,
             withUnrolled: false,
         });
-        const totalAmount = vtxos.reduce((acc, coin) => acc + BigInt(coin.value), 0n);
+        // Calculate input fees and filter out vtxos where fee >= value
+        const estimator = new Estimator(feeInfo?.intentFee ?? {});
+        const filteredVtxos = [];
+        let totalAmount = 0n;
+        for (const vtxo of vtxos) {
+            const inputFee = estimator.evalOffchainInput({
+                amount: BigInt(vtxo.value),
+                type: vtxo.virtualStatus.state === "swept"
+                    ? "recoverable"
+                    : "vtxo",
+                weight: 0,
+                birth: vtxo.createdAt,
+                expiry: vtxo.virtualStatus.batchExpiry
+                    ? new Date(vtxo.virtualStatus.batchExpiry * 1000)
+                    : undefined,
+            });
+            if (inputFee.satoshis >= vtxo.value) {
+                // skip if fees are greater than or equal to the vtxo value
+                continue;
+            }
+            filteredVtxos.push(vtxo);
+            totalAmount += BigInt(vtxo.value) - BigInt(inputFee.satoshis);
+        }
+        if (filteredVtxos.length === 0) {
+            throw new Error("No vtxos available after deducting fees");
+        }
         let change = 0n;
         if (amount) {
             if (amount > totalAmount) {
-                throw new Error("Amount is greater than total amount of vtxos");
+                throw new Error("Amount is greater than total amount of vtxos after fees");
             }
             change = totalAmount - amount;
         }
         amount = amount ?? totalAmount;
-        const fees = feeInfo.intentFee.onchainOutput;
-        if (fees > amount) {
-            throw new Error(`can't deduct fees from offboard amount (${fees} > ${amount})`);
+        const networkNames = [
+            "bitcoin",
+            "regtest",
+            "testnet",
+            "signet",
+            "mutinynet",
+        ];
+        let destinationScript;
+        for (const networkName of networkNames) {
+            try {
+                const network = networks[networkName];
+                const addr = Address(network).decode(destinationAddress);
+                destinationScript = OutScript.encode(addr);
+                break;
+            }
+            catch {
+                // Try next network
+                continue;
+            }
+        }
+        if (!destinationScript) {
+            throw new Error(`Failed to decode destination address: ${destinationAddress}`);
+        }
+        const outputFee = estimator.evalOnchainOutput({
+            amount,
+            script: hex.encode(destinationScript),
+        });
+        if (BigInt(outputFee.satoshis) > amount) {
+            throw new Error(`can't deduct fees from offboard amount (${outputFee.satoshis} > ${amount})`);
         }
-        amount -= fees;
+        amount -= BigInt(outputFee.satoshis);
         const outputs = [
             {
                 address: destinationAddress,
@@ -90,7 +175,7 @@ export class Ramps {
             });
         }
         return this.wallet.settle({
-            inputs: vtxos,
+            inputs: filteredVtxos,
             outputs,
         }, eventCallback);
     }

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

@@ -5,7 +5,6 @@ import { ReadonlyWallet, Wallet } from '../wallet.js';
 import { Request } from './request.js';
 import { Response } from './response.js';
 import { RestArkProvider } from '../../providers/ark.js';
-import { vtxosToTxs } from '../../utils/transactionHistory.js';
 import { RestIndexerProvider } from '../../providers/indexer.js';
 import { hex } from "@scure/base";
 import { IndexedDBStorageAdapter } from '../../storage/indexedDB.js';
@@ -40,8 +39,8 @@ class ReadonlyHandler {
     getBoardingAddress() {
         return this.wallet.getBoardingAddress();
     }
-    getBoardingTxs() {
-        return this.wallet.getBoardingTxs();
+    getTransactionHistory() {
+        return this.wallet.getTransactionHistory();
     }
     async handleReload(_) {
         const pending = await this.wallet.fetchPendingTxs();
@@ -127,32 +126,6 @@ export class Worker {
         const address = await this.handler.getBoardingAddress();
         return await this.walletRepository.getUtxos(address);
     }
-    async getTransactionHistory() {
-        if (!this.handler)
-            return [];
-        let txs = [];
-        try {
-            const { boardingTxs, commitmentsToIgnore: roundsToIgnore } = await this.handler.getBoardingTxs();
-            const { spendable, spent } = await this.getAllVtxos();
-            // convert VTXOs to offchain transactions
-            const offchainTxs = vtxosToTxs(spendable, spent, roundsToIgnore);
-            txs = [...boardingTxs, ...offchainTxs];
-            // sort transactions by creation time in descending order (newest first)
-            txs.sort(
-            // place createdAt = 0 (unconfirmed txs) first, then descending
-            (a, b) => {
-                if (a.createdAt === 0)
-                    return -1;
-                if (b.createdAt === 0)
-                    return 1;
-                return b.createdAt - a.createdAt;
-            });
-        }
-        catch (error) {
-            console.error("Error getting transaction history:", error);
-        }
-        return txs;
-    }
     async start(withServiceWorkerUpdate = true) {
         self.addEventListener("message", async (event) => {
             await this.handleMessage(event);
@@ -212,7 +185,7 @@ export class Worker {
         const coins = await this.handler.onchainProvider.getCoins(boardingAddress);
         await this.walletRepository.saveUtxos(boardingAddress, coins.map((utxo) => extendCoin(this.handler, utxo)));
         // Get transaction history to cache boarding txs
-        const txs = await this.getTransactionHistory();
+        const txs = await this.handler.getTransactionHistory();
         if (txs)
             await this.walletRepository.saveTransactions(address, txs);
         // unsubscribe previous subscription if any
@@ -561,7 +534,7 @@ export class Worker {
             return;
         }
         try {
-            const txs = await this.getTransactionHistory();
+            const txs = await this.handler.getTransactionHistory();
             event.source?.postMessage(Response.transactionHistory(message.id, txs));
         }
         catch (error) {

package/dist/esm/wallet/wallet.js

@@ -3,7 +3,6 @@ import * as bip68 from "bip68";
 import { tapLeafHash } from "@scure/btc-signer/payment.js";
 import { SigHash, Transaction, Address, OutScript } from "@scure/btc-signer";
 import { sha256 } from "@scure/btc-signer/utils.js";
-import { vtxosToTxs } from '../utils/transactionHistory.js';
 import { ArkAddress } from '../script/address.js';
 import { DefaultVtxo } from '../script/default.js';
 import { getNetwork } from '../networks.js';
@@ -26,6 +25,8 @@ import { ContractRepositoryImpl, } from '../repositories/contractRepository.js';
 import { extendCoin, extendVirtualCoin } 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';
 /**
  * Type guard function to check if an identity has a toReadonly method.
  */
@@ -229,30 +230,7 @@ export class ReadonlyWallet {
             scripts: [hex.encode(this.offchainTapscript.pkScript)],
         });
         const { boardingTxs, commitmentsToIgnore } = await this.getBoardingTxs();
-        const spendableVtxos = [];
-        const spentVtxos = [];
-        for (const vtxo of response.vtxos) {
-            if (isSpendable(vtxo)) {
-                spendableVtxos.push(vtxo);
-            }
-            else {
-                spentVtxos.push(vtxo);
-            }
-        }
-        // convert VTXOs to offchain transactions
-        const offchainTxs = vtxosToTxs(spendableVtxos, spentVtxos, commitmentsToIgnore);
-        const txs = [...boardingTxs, ...offchainTxs];
-        // sort transactions by creation time in descending order (newest first)
-        txs.sort(
-        // place createdAt = 0 (unconfirmed txs) first, then descending
-        (a, b) => {
-            if (a.createdAt === 0)
-                return -1;
-            if (b.createdAt === 0)
-                return 1;
-            return b.createdAt - a.createdAt;
-        });
-        return txs;
+        return buildTransactionHistory(response.vtxos, boardingTxs, commitmentsToIgnore);
     }
     async getBoardingTxs() {
         const utxos = [];
@@ -511,7 +489,23 @@ export class Wallet extends ReadonlyWallet {
         const virtualCoins = await this.getVirtualCoins({
             withRecoverable: false,
         });
-        const selected = selectVirtualCoins(virtualCoins, params.amount);
+        let selected;
+        if (params.selectedVtxos) {
+            const selectedVtxoSum = params.selectedVtxos
+                .map((v) => v.value)
+                .reduce((a, b) => a + b, 0);
+            if (selectedVtxoSum < params.amount) {
+                throw new Error("Selected VTXOs do not cover specified amount");
+            }
+            const changeAmount = selectedVtxoSum - params.amount;
+            selected = {
+                inputs: params.selectedVtxos,
+                changeAmount: BigInt(changeAmount),
+            };
+        }
+        else {
+            selected = selectVirtualCoins(virtualCoins, params.amount);
+        }
         const selectedLeaf = this.offchainTapscript.forfeit();
         if (!selectedLeaf) {
             throw new Error("Selected leaf not found");
@@ -641,25 +635,64 @@ export class Wallet extends ReadonlyWallet {
         // if no params are provided, use all non expired boarding utxos and offchain vtxos as inputs
         // and send all to the offchain address
         if (!params) {
+            const { fees } = await this.arkProvider.getInfo();
+            const estimator = new Estimator(fees.intentFee);
             let amount = 0;
             const exitScript = CSVMultisigTapscript.decode(hex.decode(this.boardingTapscript.exitScript));
             const boardingTimelock = exitScript.params.timelock;
             const boardingUtxos = (await this.getBoardingUtxos()).filter((utxo) => !hasBoardingTxExpired(utxo, boardingTimelock));
-            amount += boardingUtxos.reduce((sum, input) => sum + input.value, 0);
+            const filteredBoardingUtxos = [];
+            for (const utxo of boardingUtxos) {
+                const inputFee = estimator.evalOnchainInput({
+                    amount: BigInt(utxo.value),
+                });
+                if (inputFee.value >= utxo.value) {
+                    // skip if fees are greater than the utxo value
+                    continue;
+                }
+                filteredBoardingUtxos.push(utxo);
+                amount += utxo.value - inputFee.satoshis;
+            }
             const vtxos = await this.getVtxos({ withRecoverable: true });
-            amount += vtxos.reduce((sum, input) => sum + input.value, 0);
-            const inputs = [...boardingUtxos, ...vtxos];
+            const filteredVtxos = [];
+            for (const vtxo of vtxos) {
+                const inputFee = estimator.evalOffchainInput({
+                    amount: BigInt(vtxo.value),
+                    type: vtxo.virtualStatus.state === "swept"
+                        ? "recoverable"
+                        : "vtxo",
+                    weight: 0,
+                    birth: vtxo.createdAt,
+                    expiry: vtxo.virtualStatus.batchExpiry
+                        ? new Date(vtxo.virtualStatus.batchExpiry * 1000)
+                        : new Date(),
+                });
+                if (inputFee.value >= vtxo.value) {
+                    // skip if fees are greater than the vtxo value
+                    continue;
+                }
+                filteredVtxos.push(vtxo);
+                amount += vtxo.value - inputFee.satoshis;
+            }
+            const inputs = [...filteredBoardingUtxos, ...filteredVtxos];
             if (inputs.length === 0) {
                 throw new Error("No inputs found");
             }
+            const output = {
+                address: await this.getAddress(),
+                amount: BigInt(amount),
+            };
+            const outputFee = estimator.evalOffchainOutput({
+                amount: output.amount,
+                script: hex.encode(ArkAddress.decode(output.address).pkScript),
+            });
+            output.amount -= BigInt(outputFee.satoshis);
+            if (output.amount <= this.dustAmount) {
+                throw new Error("Output amount is below dust limit");
+            }
             params = {
                 inputs,
-                outputs: [
-                    {
-                        address: await this.getAddress(),
-                        amount: BigInt(amount),
-                    },
-                ],
+                outputs: [output],
             };
         }
         const onchainOutputIndexes = [];