@arkade-os/sdk 0.3.3 → 0.3.5

package/README.md

@@ -171,7 +171,13 @@ Collaborative exit or "offboarding" allows you to withdraw your virtual funds to
 ```typescript
 import { Ramps } from '@arkade-os/sdk'
 
-const exitTxid = await new Ramps(wallet).offboard(onchainAddress);
+// Get fee information from the server
+const info = await wallet.arkProvider.getInfo();
+
+const exitTxid = await new Ramps(wallet).offboard(
+  onchainAddress,
+  info.fees
+);
 ```
 
 ### Unilateral Exit

package/dist/cjs/identity/singleKey.js

@@ -83,8 +83,8 @@ class SingleKey {
     }
     async signMessage(message, signatureType = "schnorr") {
         if (signatureType === "ecdsa")
-            return (0, secp256k1_1.sign)(message, this.key, { prehash: false });
-        return secp256k1_1.schnorr.sign(message, this.key);
+            return (0, secp256k1_1.signAsync)(message, this.key, { prehash: false });
+        return secp256k1_1.schnorr.signAsync(message, this.key);
     }
 }
 exports.SingleKey = SingleKey;

package/dist/cjs/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = exports.Unroll = exports.P2A = exports.TxTree = exports.Intent = exports.ContractRepositoryImpl = exports.WalletRepositoryImpl = exports.networks = exports.ArkNote = exports.hasBoardingTxExpired = exports.waitForIncomingFunds = exports.verifyTapscriptSignatures = exports.buildOffchainTx = exports.ConditionWitness = exports.VtxoTaprootTree = exports.VtxoTreeExpiry = exports.CosignerPublicKey = exports.getArkPsbtFields = exports.setArkPsbtField = exports.ArkPsbtFieldKeyType = exports.ArkPsbtFieldKey = exports.TapTreeCoder = exports.CLTVMultisigTapscript = exports.ConditionMultisigTapscript = exports.ConditionCSVMultisigTapscript = exports.CSVMultisigTapscript = exports.MultisigTapscript = exports.decodeTapscript = exports.Response = exports.Request = exports.ServiceWorkerWallet = exports.Worker = exports.setupServiceWorker = exports.SettlementEventType = exports.ChainTxType = exports.IndexerTxType = exports.TxType = exports.VHTLC = exports.VtxoScript = exports.DefaultVtxo = exports.ArkAddress = exports.RestIndexerProvider = exports.RestArkProvider = exports.EsploraProvider = exports.ESPLORA_URL = exports.VtxoManager = exports.Ramps = exports.OnchainWallet = exports.SingleKey = exports.Wallet = void 0;
-exports.maybeArkError = exports.ArkError = void 0;
+exports.Unroll = exports.P2A = exports.TxTree = exports.Intent = exports.ContractRepositoryImpl = exports.WalletRepositoryImpl = exports.networks = exports.ArkNote = exports.combineTapscriptSigs = exports.hasBoardingTxExpired = exports.waitForIncomingFunds = exports.verifyTapscriptSignatures = exports.buildOffchainTx = exports.ConditionWitness = exports.VtxoTaprootTree = exports.VtxoTreeExpiry = exports.CosignerPublicKey = exports.getArkPsbtFields = exports.setArkPsbtField = exports.ArkPsbtFieldKeyType = exports.ArkPsbtFieldKey = exports.TapTreeCoder = exports.CLTVMultisigTapscript = exports.ConditionMultisigTapscript = exports.ConditionCSVMultisigTapscript = exports.CSVMultisigTapscript = exports.MultisigTapscript = exports.decodeTapscript = exports.Response = exports.Request = exports.ServiceWorkerWallet = exports.Worker = exports.setupServiceWorker = exports.SettlementEventType = exports.ChainTxType = exports.IndexerTxType = exports.TxType = exports.VHTLC = exports.VtxoScript = exports.DefaultVtxo = exports.ArkAddress = exports.RestIndexerProvider = exports.RestArkProvider = exports.EsploraProvider = exports.ESPLORA_URL = exports.VtxoManager = exports.Ramps = exports.OnchainWallet = exports.SingleKey = exports.Wallet = void 0;
+exports.maybeArkError = exports.ArkError = exports.Transaction = void 0;
 const transaction_1 = require("./utils/transaction");
 Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return transaction_1.Transaction; } });
 const singleKey_1 = require("./identity/singleKey");
@@ -55,6 +55,7 @@ const arkTransaction_1 = require("./utils/arkTransaction");
 Object.defineProperty(exports, "hasBoardingTxExpired", { enumerable: true, get: function () { return arkTransaction_1.hasBoardingTxExpired; } });
 Object.defineProperty(exports, "buildOffchainTx", { enumerable: true, get: function () { return arkTransaction_1.buildOffchainTx; } });
 Object.defineProperty(exports, "verifyTapscriptSignatures", { enumerable: true, get: function () { return arkTransaction_1.verifyTapscriptSignatures; } });
+Object.defineProperty(exports, "combineTapscriptSigs", { enumerable: true, get: function () { return arkTransaction_1.combineTapscriptSigs; } });
 const unknownFields_1 = require("./utils/unknownFields");
 Object.defineProperty(exports, "VtxoTaprootTree", { enumerable: true, get: function () { return unknownFields_1.VtxoTaprootTree; } });
 Object.defineProperty(exports, "ConditionWitness", { enumerable: true, get: function () { return unknownFields_1.ConditionWitness; } });

package/dist/cjs/providers/ark.js

@@ -46,7 +46,14 @@ class RestArkProvider {
             })) ?? [],
             digest: fromServer.digest ?? "",
             dust: BigInt(fromServer.dust ?? 0),
-            fees: fromServer.fees,
+            fees: {
+                intentFee: {
+                    ...fromServer.fees?.intentFee,
+                    onchainInput: BigInt(fromServer.fees?.intentFee?.onchainInput ?? 0),
+                    onchainOutput: BigInt(fromServer.fees?.intentFee?.onchainOutput ?? 0),
+                },
+                txFeeRate: fromServer?.fees?.txFeeRate ?? "",
+            },
             forfeitAddress: fromServer.forfeitAddress ?? "",
             forfeitPubkey: fromServer.forfeitPubkey ?? "",
             network: fromServer.network ?? "",
@@ -139,7 +146,7 @@ class RestArkProvider {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                proof: {
+                intent: {
                     proof: intent.proof,
                     message: intent.message,
                 },

package/dist/cjs/repositories/contractRepository.js

@@ -1,22 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractRepositoryImpl = void 0;
+const getContractStorageKey = (id, key) => `contract:${id}:${key}`;
+const getCollectionStorageKey = (type) => `collection:${type}`;
 class ContractRepositoryImpl {
     constructor(storage) {
-        this.cache = new Map();
         this.storage = storage;
     }
     async getContractData(contractId, key) {
-        const storageKey = `contract:${contractId}:${key}`;
-        const cached = this.cache.get(storageKey);
-        if (cached !== undefined)
-            return cached;
-        const stored = await this.storage.getItem(storageKey);
+        const stored = await this.storage.getItem(getContractStorageKey(contractId, key));
         if (!stored)
             return null;
         try {
             const data = JSON.parse(stored);
-            this.cache.set(storageKey, data);
             return data;
         }
         catch (error) {
@@ -25,49 +21,33 @@ class ContractRepositoryImpl {
         }
     }
     async setContractData(contractId, key, data) {
-        const storageKey = `contract:${contractId}:${key}`;
         try {
-            // First persist to storage, only update cache if successful
-            await this.storage.setItem(storageKey, JSON.stringify(data));
-            this.cache.set(storageKey, data);
+            await this.storage.setItem(getContractStorageKey(contractId, key), JSON.stringify(data));
         }
         catch (error) {
-            // Storage operation failed, cache remains unchanged
             console.error(`Failed to persist contract data for ${contractId}:${key}:`, error);
             throw error; // Rethrow to notify caller of failure
         }
     }
     async deleteContractData(contractId, key) {
-        const storageKey = `contract:${contractId}:${key}`;
         try {
-            // First remove from persistent storage, only delete from cache if successful
-            await this.storage.removeItem(storageKey);
-            this.cache.delete(storageKey);
+            await this.storage.removeItem(getContractStorageKey(contractId, key));
         }
         catch (error) {
-            // Storage operation failed, cache remains unchanged
             console.error(`Failed to remove contract data for ${contractId}:${key}:`, error);
             throw error; // Rethrow to notify caller of failure
         }
     }
     async getContractCollection(contractType) {
-        const storageKey = `collection:${contractType}`;
-        const cached = this.cache.get(storageKey);
-        if (cached !== undefined)
-            return cached;
-        const stored = await this.storage.getItem(storageKey);
-        if (!stored) {
-            this.cache.set(storageKey, []);
+        const stored = await this.storage.getItem(getCollectionStorageKey(contractType));
+        if (!stored)
             return [];
-        }
         try {
             const collection = JSON.parse(stored);
-            this.cache.set(storageKey, collection);
             return collection;
         }
         catch (error) {
             console.error(`Failed to parse contract collection ${contractType}:`, error);
-            this.cache.set(storageKey, []);
             return [];
         }
     }
@@ -94,14 +74,10 @@ class ContractRepositoryImpl {
             // Add new item
             newCollection = [...collection, item];
         }
-        const storageKey = `collection:${contractType}`;
         try {
-            // First persist to storage, only update cache if successful
-            await this.storage.setItem(storageKey, JSON.stringify(newCollection));
-            this.cache.set(storageKey, newCollection);
+            await this.storage.setItem(getCollectionStorageKey(contractType), JSON.stringify(newCollection));
         }
         catch (error) {
-            // Storage operation failed, cache remains unchanged
             console.error(`Failed to persist contract collection ${contractType}:`, error);
             throw error; // Rethrow to notify caller of failure
         }
@@ -114,21 +90,16 @@ class ContractRepositoryImpl {
         const collection = await this.getContractCollection(contractType);
         // Build new collection without the specified item
         const filtered = collection.filter((item) => item[idField] !== id);
-        const storageKey = `collection:${contractType}`;
         try {
-            // First persist to storage, only update cache if successful
-            await this.storage.setItem(storageKey, JSON.stringify(filtered));
-            this.cache.set(storageKey, filtered);
+            await this.storage.setItem(getCollectionStorageKey(contractType), JSON.stringify(filtered));
         }
         catch (error) {
-            // Storage operation failed, cache remains unchanged
             console.error(`Failed to persist contract collection removal for ${contractType}:`, error);
             throw error; // Rethrow to notify caller of failure
         }
     }
     async clearContractData() {
         await this.storage.clear();
-        this.cache.clear();
     }
 }
 exports.ContractRepositoryImpl = ContractRepositoryImpl;

package/dist/cjs/repositories/walletRepository.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WalletRepositoryImpl = void 0;
 const base_1 = require("@scure/base");
 const btc_signer_1 = require("@scure/btc-signer");
+const getVtxosStorageKey = (address) => `vtxos:${address}`;
+const getUtxosStorageKey = (address) => `utxos:${address}`;
+const getTransactionsStorageKey = (address) => `tx:${address}`;
+const walletStateStorageKey = "wallet:state";
 // Utility functions for (de)serializing complex structures
 const toHex = (b) => (b ? base_1.hex.encode(b) : undefined);
 const fromHex = (h) => h ? base_1.hex.decode(h) : undefined;
@@ -47,33 +51,17 @@ const deserializeUtxo = (o) => ({
 class WalletRepositoryImpl {
     constructor(storage) {
         this.storage = storage;
-        this.cache = {
-            vtxos: new Map(),
-            utxos: new Map(),
-            transactions: new Map(),
-            walletState: null,
-            initialized: new Set(),
-        };
     }
     async getVtxos(address) {
-        const cacheKey = `vtxos:${address}`;
-        if (this.cache.vtxos.has(address)) {
-            return this.cache.vtxos.get(address);
-        }
-        const stored = await this.storage.getItem(cacheKey);
-        if (!stored) {
-            this.cache.vtxos.set(address, []);
+        const stored = await this.storage.getItem(getVtxosStorageKey(address));
+        if (!stored)
             return [];
-        }
         try {
             const parsed = JSON.parse(stored);
-            const vtxos = parsed.map(deserializeVtxo);
-            this.cache.vtxos.set(address, vtxos.slice());
-            return vtxos.slice();
+            return parsed.map(deserializeVtxo);
         }
         catch (error) {
             console.error(`Failed to parse VTXOs for address ${address}:`, error);
-            this.cache.vtxos.set(address, []);
             return [];
         }
     }
@@ -88,39 +76,27 @@ class WalletRepositoryImpl {
                 storedVtxos.push(vtxo);
             }
         }
-        this.cache.vtxos.set(address, storedVtxos.slice());
-        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(storedVtxos.map(serializeVtxo)));
+        await this.storage.setItem(getVtxosStorageKey(address), JSON.stringify(storedVtxos.map(serializeVtxo)));
     }
     async removeVtxo(address, vtxoId) {
         const vtxos = await this.getVtxos(address);
         const [txid, vout] = vtxoId.split(":");
         const filtered = vtxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout, 10)));
-        this.cache.vtxos.set(address, filtered.slice());
-        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(filtered.map(serializeVtxo)));
+        await this.storage.setItem(getVtxosStorageKey(address), JSON.stringify(filtered.map(serializeVtxo)));
     }
     async clearVtxos(address) {
-        this.cache.vtxos.set(address, []);
-        await this.storage.removeItem(`vtxos:${address}`);
+        await this.storage.removeItem(getVtxosStorageKey(address));
     }
     async getUtxos(address) {
-        const cacheKey = `utxos:${address}`;
-        if (this.cache.utxos.has(address)) {
-            return this.cache.utxos.get(address);
-        }
-        const stored = await this.storage.getItem(cacheKey);
-        if (!stored) {
-            this.cache.utxos.set(address, []);
+        const stored = await this.storage.getItem(getUtxosStorageKey(address));
+        if (!stored)
             return [];
-        }
         try {
             const parsed = JSON.parse(stored);
-            const utxos = parsed.map(deserializeUtxo);
-            this.cache.utxos.set(address, utxos.slice());
-            return utxos.slice();
+            return parsed.map(deserializeUtxo);
         }
         catch (error) {
             console.error(`Failed to parse UTXOs for address ${address}:`, error);
-            this.cache.utxos.set(address, []);
             return [];
         }
     }
@@ -135,38 +111,27 @@ class WalletRepositoryImpl {
                 storedUtxos.push(utxo);
             }
         });
-        this.cache.utxos.set(address, storedUtxos.slice());
-        await this.storage.setItem(`utxos:${address}`, JSON.stringify(storedUtxos.map(serializeUtxo)));
+        await this.storage.setItem(getUtxosStorageKey(address), JSON.stringify(storedUtxos.map(serializeUtxo)));
     }
     async removeUtxo(address, utxoId) {
         const utxos = await this.getUtxos(address);
         const [txid, vout] = utxoId.split(":");
         const filtered = utxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout, 10)));
-        this.cache.utxos.set(address, filtered.slice());
-        await this.storage.setItem(`utxos:${address}`, JSON.stringify(filtered.map(serializeUtxo)));
+        await this.storage.setItem(getUtxosStorageKey(address), JSON.stringify(filtered.map(serializeUtxo)));
     }
     async clearUtxos(address) {
-        this.cache.utxos.set(address, []);
-        await this.storage.removeItem(`utxos:${address}`);
+        await this.storage.removeItem(getUtxosStorageKey(address));
     }
     async getTransactionHistory(address) {
-        const cacheKey = `tx:${address}`;
-        if (this.cache.transactions.has(address)) {
-            return this.cache.transactions.get(address);
-        }
-        const stored = await this.storage.getItem(cacheKey);
-        if (!stored) {
-            this.cache.transactions.set(address, []);
+        const storageKey = getTransactionsStorageKey(address);
+        const stored = await this.storage.getItem(storageKey);
+        if (!stored)
             return [];
-        }
         try {
-            const transactions = JSON.parse(stored);
-            this.cache.transactions.set(address, transactions);
-            return transactions.slice();
+            return JSON.parse(stored);
         }
         catch (error) {
             console.error(`Failed to parse transactions for address ${address}:`, error);
-            this.cache.transactions.set(address, []);
             return [];
         }
     }
@@ -181,40 +146,26 @@ class WalletRepositoryImpl {
                 storedTransactions.push(tx);
             }
         }
-        this.cache.transactions.set(address, storedTransactions);
-        await this.storage.setItem(`tx:${address}`, JSON.stringify(storedTransactions));
+        await this.storage.setItem(getTransactionsStorageKey(address), JSON.stringify(storedTransactions));
     }
     async clearTransactions(address) {
-        this.cache.transactions.set(address, []);
-        await this.storage.removeItem(`tx:${address}`);
+        await this.storage.removeItem(getTransactionsStorageKey(address));
     }
     async getWalletState() {
-        if (this.cache.walletState !== null ||
-            this.cache.initialized.has("walletState")) {
-            return this.cache.walletState;
-        }
-        const stored = await this.storage.getItem("wallet:state");
-        if (!stored) {
-            this.cache.walletState = null;
-            this.cache.initialized.add("walletState");
+        const stored = await this.storage.getItem(walletStateStorageKey);
+        if (!stored)
             return null;
-        }
         try {
             const state = JSON.parse(stored);
-            this.cache.walletState = state;
-            this.cache.initialized.add("walletState");
             return state;
         }
         catch (error) {
             console.error("Failed to parse wallet state:", error);
-            this.cache.walletState = null;
-            this.cache.initialized.add("walletState");
             return null;
         }
     }
     async saveWalletState(state) {
-        this.cache.walletState = state;
-        await this.storage.setItem("wallet:state", JSON.stringify(state));
+        await this.storage.setItem(walletStateStorageKey, JSON.stringify(state));
     }
 }
 exports.WalletRepositoryImpl = WalletRepositoryImpl;

package/dist/cjs/utils/arkTransaction.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildOffchainTx = buildOffchainTx;
 exports.hasBoardingTxExpired = hasBoardingTxExpired;
 exports.verifyTapscriptSignatures = verifyTapscriptSignatures;
+exports.combineTapscriptSigs = combineTapscriptSigs;
 const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
 const base_1 = require("@scure/base");
 const btc_signer_1 = require("@scure/btc-signer");
@@ -25,6 +26,17 @@ const transaction_1 = require("./transaction");
  * @returns Object containing the virtual transaction and checkpoint transactions
  */
 function buildOffchainTx(inputs, outputs, serverUnrollScript) {
+    let hasOpReturn = false;
+    for (const [index, output] of outputs.entries()) {
+        if (!output.script)
+            throw new Error(`missing output script ${index}`);
+        const isOpReturn = btc_signer_1.Script.decode(output.script)[0] === "RETURN";
+        if (!isOpReturn)
+            continue;
+        if (hasOpReturn)
+            throw new Error("multiple OP_RETURN outputs");
+        hasOpReturn = true;
+    }
     const checkpoints = inputs.map((input) => buildCheckpointTx(input, serverUnrollScript));
     const arkTx = buildVirtualTx(checkpoints.map((c) => c.input), outputs);
     return {
@@ -209,3 +221,20 @@ function verifyTapscriptSignatures(tx, inputIndex, requiredSigners, excludePubke
         throw new Error(`Missing signatures from: ${missingSigners.map((pk) => pk.slice(0, 16)).join(", ")}...`);
     }
 }
+/**
+ * Merges the signed transaction with the original transaction
+ * @param signedTx signed transaction
+ * @param originalTx original transaction
+ */
+function combineTapscriptSigs(signedTx, originalTx) {
+    for (let i = 0; i < signedTx.inputsLength; i++) {
+        const input = originalTx.getInput(i);
+        const signedInput = signedTx.getInput(i);
+        if (!input.tapScriptSig)
+            throw new Error("No tapScriptSig");
+        originalTx.updateInput(i, {
+            tapScriptSig: input.tapScriptSig?.concat(signedInput.tapScriptSig),
+        });
+    }
+    return originalTx;
+}

package/dist/cjs/utils/transactionHistory.js

@@ -14,6 +14,10 @@ function vtxosToTxs(spendable, spent, boardingBatchTxids) {
     // All vtxos are received unless:
     // - they resulted from a settlement (either boarding or refresh)
     // - they are the change of a spend tx
+    // - they were spent in a payment (have arkTxId set)
+    // - they resulted from a payment (their txid matches an arkTxId of a spent vtxo)
+    // First, collect all arkTxIds from spent vtxos to identify payment transactions
+    const paymentArkTxIds = new Set(spent.filter((v) => v.arkTxId).map((v) => v.arkTxId));
     let vtxosLeftToCheck = [...spent];
     for (const vtxo of [...spendable, ...spent]) {
         if (vtxo.virtualStatus.state !== "preconfirmed" &&
@@ -21,6 +25,16 @@ function vtxosToTxs(spendable, spent, boardingBatchTxids) {
             vtxo.virtualStatus.commitmentTxIds.some((txid) => boardingBatchTxids.has(txid))) {
             continue;
         }
+        // Skip vtxos that were spent in a payment transaction
+        // These will be handled in the sent transaction section below
+        if (vtxo.arkTxId) {
+            continue;
+        }
+        // Skip vtxos that resulted from a payment transaction
+        // (their txid matches an arkTxId from a spent vtxo)
+        if (paymentArkTxIds.has(vtxo.txid)) {
+            continue;
+        }
         const settleVtxos = findVtxosSpentInSettlement(vtxosLeftToCheck, vtxo);
         vtxosLeftToCheck = removeVtxosFromList(vtxosLeftToCheck, settleVtxos);
         const settleAmount = reduceVtxosAmount(settleVtxos);
@@ -56,21 +70,17 @@ function vtxosToTxs(spendable, spent, boardingBatchTxids) {
     // 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, []);
-            }
-            const currentVtxos = vtxosByTxid.get(v.settledBy);
-            vtxosByTxid.set(v.settledBy, [...currentVtxos, v]);
-        }
-        if (!v.arkTxId) {
+        // Prefer arkTxId over settledBy to avoid duplicates
+        // A vtxo should only be grouped once
+        const groupKey = v.arkTxId || v.settledBy;
+        if (!groupKey) {
             continue;
         }
-        if (!vtxosByTxid.has(v.arkTxId)) {
-            vtxosByTxid.set(v.arkTxId, []);
+        if (!vtxosByTxid.has(groupKey)) {
+            vtxosByTxid.set(groupKey, []);
         }
-        const currentVtxos = vtxosByTxid.get(v.arkTxId);
-        vtxosByTxid.set(v.arkTxId, [...currentVtxos, v]);
+        const currentVtxos = vtxosByTxid.get(groupKey);
+        vtxosByTxid.set(groupKey, [...currentVtxos, v]);
     }
     for (const [sb, vtxos] of vtxosByTxid) {
         const resultedVtxos = findVtxosResultedFromTxid([...spendable, ...spent], sb);
@@ -85,7 +95,13 @@ function vtxosToTxs(spendable, spent, boardingBatchTxids) {
             boardingTxid: "",
             arkTxid: "",
         };
-        if (vtxo.virtualStatus.state === "preconfirmed") {
+        // Use the grouping key (sb) as arkTxid if it looks like an arkTxId
+        // (i.e., if the spent vtxos had arkTxId set, use that instead of result vtxo's txid)
+        const isArkTxId = vtxos.some((v) => v.arkTxId === sb);
+        if (isArkTxId) {
+            txKey.arkTxid = sb;
+        }
+        else if (vtxo.virtualStatus.state === "preconfirmed") {
             txKey.arkTxid = vtxo.txid;
         }
         txs.push({

package/dist/cjs/wallet/ramps.js

@@ -56,10 +56,11 @@ class Ramps {
      * Offboard vtxos, or "collaborative exit" vtxos to onchain address.
      *
      * @param destinationAddress - The destination address to offboard to.
+     * @param feeInfo - The fee info to deduct from the offboard amount.
      * @param amount - The amount to offboard. If not provided, the total amount of vtxos will be offboarded.
      * @param eventCallback - The callback to receive settlement events. optional.
      */
-    async offboard(destinationAddress, amount, eventCallback) {
+    async offboard(destinationAddress, feeInfo, amount, eventCallback) {
         const vtxos = await this.wallet.getVtxos({
             withRecoverable: true,
             withUnrolled: false,
@@ -73,6 +74,11 @@ class Ramps {
             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})`);
+        }
+        amount -= fees;
         const outputs = [
             {
                 address: destinationAddress,

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

@@ -77,7 +77,6 @@ class Worker {
             const { boardingTxs, commitmentsToIgnore: roundsToIgnore } = await this.wallet.getBoardingTxs();
             const { spendable, spent } = await this.getAllVtxos();
             // convert VTXOs to offchain transactions
-            console.log("getTransactionHistory - vtxosToTxs:", spendable);
             const offchainTxs = (0, transactionHistory_1.vtxosToTxs)(spendable, spent, roundsToIgnore);
             txs = [...boardingTxs, ...offchainTxs];
             // sort transactions by creation time in descending order (newest first)