@arkade-os/sdk 0.3.3 → 0.3.5

package/dist/cjs/wallet/wallet.js

@@ -146,12 +146,29 @@ class Wallet {
         const esploraUrl = config.esploraUrl || onchain_1.ESPLORA_URL[info.network];
         // Use provided onchainProvider instance or create a new one
         const onchainProvider = config.onchainProvider || new onchain_1.EsploraProvider(esploraUrl);
-        // Generate timelocks
-        const exitTimelock = {
+        // validate unilateral exit timelock passed in config if any
+        if (config.exitTimelock) {
+            const { value, type } = config.exitTimelock;
+            if ((value < 512n && type !== "blocks") ||
+                (value >= 512n && type !== "seconds")) {
+                throw new Error("invalid exitTimelock");
+            }
+        }
+        // create unilateral exit timelock
+        const exitTimelock = config.exitTimelock ?? {
             value: info.unilateralExitDelay,
             type: info.unilateralExitDelay < 512n ? "blocks" : "seconds",
         };
-        const boardingTimelock = {
+        // validate boarding timelock passed in config if any
+        if (config.boardingTimelock) {
+            const { value, type } = config.boardingTimelock;
+            if ((value < 512n && type !== "blocks") ||
+                (value >= 512n && type !== "seconds")) {
+                throw new Error("invalid boardingTimelock");
+            }
+        }
+        // create boarding timelock
+        const boardingTimelock = config.boardingTimelock ?? {
             value: info.boardingExitDelay,
             type: info.boardingExitDelay < 512n ? "blocks" : "seconds",
         };
@@ -414,14 +431,13 @@ class Wallet {
             });
         }
         const tapTree = this.offchainTapscript.encode();
-        let offchainTx = (0, arkTransaction_1.buildOffchainTx)(selected.inputs.map((input) => ({
+        const offchainTx = (0, arkTransaction_1.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(base_1.base64.encode(signedVirtualTx.toPSBT()), offchainTx.checkpoints.map((c) => base_1.base64.encode(c.toPSBT())));
-        // TODO persist final virtual tx and checkpoints to repository
         // sign the checkpoints
         const finalCheckpoints = await Promise.all(signedCheckpointTxs.map(async (c) => {
             const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(c));
@@ -429,7 +445,78 @@ class Wallet {
             return base_1.base64.encode(signedCheckpoint.toPSBT());
         }));
         await this.arkProvider.finalizeTx(arkTxid, finalCheckpoints);
-        return arkTxid;
+        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 = (0, utils_1.extendVirtualCoin)(this, input);
+                const checkpointB64 = signedCheckpointTxs[inputIndex];
+                const checkpoint = btc_signer_1.Transaction.fromPSBT(base_1.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.exit(),
+                    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, [
+                {
+                    key: {
+                        boardingTxid: "",
+                        commitmentTxid: "",
+                        arkTxid: arkTxid,
+                    },
+                    amount: params.amount,
+                    type: _1.TxType.TxSent,
+                    settled: false,
+                    createdAt: Date.now(),
+                },
+            ]);
+        }
+        catch (e) {
+            console.warn("error saving offchain tx to repository", e);
+        }
+        finally {
+            return arkTxid;
+        }
     }
     async settle(params, eventCallback) {
         if (params?.inputs) {
@@ -702,7 +789,8 @@ class Wallet {
             (async () => {
                 try {
                     for await (const update of subscription) {
-                        if (update.newVtxos?.length > 0) {
+                        if (update.newVtxos?.length > 0 ||
+                            update.spentVtxos?.length > 0) {
                             eventCallback({
                                 type: "vtxo",
                                 newVtxos: update.newVtxos.map((vtxo) => (0, utils_1.extendVirtualCoin)(this, vtxo)),
@@ -869,13 +957,12 @@ class Wallet {
         }
     }
     async makeRegisterIntentSignature(coins, outputs, onchainOutputsIndexes, cosignerPubKeys) {
-        const nowSeconds = Math.floor(Date.now() / 1000);
         const inputs = this.prepareIntentProofInputs(coins);
         const message = {
             type: "register",
             onchain_output_indexes: onchainOutputsIndexes,
-            valid_at: nowSeconds,
-            expire_at: nowSeconds + 2 * 60, // valid for 2 minutes
+            valid_at: 0,
+            expire_at: 0,
             cosigners_public_keys: cosignerPubKeys,
         };
         const encodedMessage = JSON.stringify(message, null, 0);
@@ -887,11 +974,10 @@ class Wallet {
         };
     }
     async makeDeleteIntentSignature(coins) {
-        const nowSeconds = Math.floor(Date.now() / 1000);
         const inputs = this.prepareIntentProofInputs(coins);
         const message = {
             type: "delete",
-            expire_at: nowSeconds + 2 * 60, // valid for 2 minutes
+            expire_at: 0,
         };
         const encodedMessage = JSON.stringify(message, null, 0);
         const proof = intent_1.Intent.create(encodedMessage, inputs, []);

package/dist/esm/identity/singleKey.js

@@ -2,7 +2,7 @@ import { pubECDSA, pubSchnorr, randomPrivateKeyBytes, } from "@scure/btc-signer/
 import { SigHash } from "@scure/btc-signer";
 import { hex } from "@scure/base";
 import { TreeSignerSession } from '../tree/signingSession.js';
-import { schnorr, sign } from "@noble/secp256k1";
+import { schnorr, signAsync } from "@noble/secp256k1";
 const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
 /**
  * In-memory single key implementation for Bitcoin transaction signing.
@@ -80,7 +80,7 @@ export class SingleKey {
     }
     async signMessage(message, signatureType = "schnorr") {
         if (signatureType === "ecdsa")
-            return sign(message, this.key, { prehash: false });
-        return schnorr.sign(message, this.key);
+            return signAsync(message, this.key, { prehash: false });
+        return schnorr.signAsync(message, this.key);
     }
 }

package/dist/esm/index.js

@@ -18,7 +18,7 @@ import { Response } from './wallet/serviceWorker/response.js';
 import { ESPLORA_URL, EsploraProvider, } from './providers/onchain.js';
 import { RestArkProvider, SettlementEventType, } from './providers/ark.js';
 import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, } from './script/tapscript.js';
-import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, } from './utils/arkTransaction.js';
+import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, combineTapscriptSigs, } from './utils/arkTransaction.js';
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry, } from './utils/unknownFields.js';
 import { Intent } from './intent/index.js';
 import { ArkNote } from './arknote/index.js';
@@ -45,7 +45,7 @@ decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTa
 // Ark PSBT fields
 ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, 
 // Utils
-buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, 
+buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, combineTapscriptSigs, 
 // Arknote
 ArkNote, 
 // Network

package/dist/esm/providers/ark.js

@@ -42,7 +42,14 @@ export 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 ?? "",
@@ -135,7 +142,7 @@ export class RestArkProvider {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                proof: {
+                intent: {
                     proof: intent.proof,
                     message: intent.message,
                 },

package/dist/esm/repositories/contractRepository.js

@@ -1,19 +1,15 @@
+const getContractStorageKey = (id, key) => `contract:${id}:${key}`;
+const getCollectionStorageKey = (type) => `collection:${type}`;
 export 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) {
@@ -22,49 +18,33 @@ export 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 [];
         }
     }
@@ -91,14 +71,10 @@ export 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
         }
@@ -111,20 +87,15 @@ export 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();
     }
 }

package/dist/esm/repositories/walletRepository.js

@@ -1,5 +1,9 @@
 import { hex } from "@scure/base";
 import { TaprootControlBlock } from "@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 ? hex.encode(b) : undefined);
 const fromHex = (h) => h ? hex.decode(h) : undefined;
@@ -44,33 +48,17 @@ const deserializeUtxo = (o) => ({
 export 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 [];
         }
     }
@@ -85,39 +73,27 @@ export 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 [];
         }
     }
@@ -132,38 +108,27 @@ export 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 [];
         }
     }
@@ -178,39 +143,25 @@ export 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));
     }
 }

package/dist/esm/utils/arkTransaction.js

@@ -1,6 +1,6 @@
 import { schnorr } from "@noble/curves/secp256k1.js";
 import { hex } from "@scure/base";
-import { DEFAULT_SEQUENCE, SigHash } from "@scure/btc-signer";
+import { DEFAULT_SEQUENCE, Script, SigHash } from "@scure/btc-signer";
 import { tapLeafHash } from "@scure/btc-signer/payment.js";
 import { CLTVMultisigTapscript, decodeTapscript, } from '../script/tapscript.js';
 import { scriptFromTapLeafScript, VtxoScript, } from '../script/base.js';
@@ -20,6 +20,17 @@ import { Transaction } from './transaction.js';
  * @returns Object containing the virtual transaction and checkpoint transactions
  */
 export 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 = 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 {
@@ -204,3 +215,20 @@ export function verifyTapscriptSignatures(tx, inputIndex, requiredSigners, exclu
         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
+ */
+export 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/esm/utils/transactionHistory.js

@@ -11,6 +11,10 @@ export 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" &&
@@ -18,6 +22,16 @@ export 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);
@@ -53,21 +67,17 @@ export 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);
@@ -82,7 +92,13 @@ export 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({