@arkade-os/sdk 0.3.6 → 0.3.8

package/dist/cjs/utils/transactionHistory.js

@@ -14,10 +14,6 @@ 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" &&
@@ -25,16 +21,6 @@ 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);
@@ -48,7 +34,7 @@ function vtxosToTxs(spendable, spent, boardingBatchTxids) {
             continue; // settlement or change, ignore
         }
         const txKey = {
-            commitmentTxid: vtxo.spentBy || "",
+            commitmentTxid: "",
             boardingTxid: "",
             arkTxid: "",
         };
@@ -59,6 +45,10 @@ function vtxosToTxs(spendable, spent, boardingBatchTxids) {
                 settled = true;
             }
         }
+        else {
+            txKey.commitmentTxid =
+                vtxo.virtualStatus.commitmentTxIds?.[0] || "";
+        }
         txs.push({
             key: txKey,
             amount: vtxo.value - settleAmount - spentAmount,
@@ -70,17 +60,21 @@ function vtxosToTxs(spendable, spent, boardingBatchTxids) {
     // vtxos by settled by or ark txid
     const vtxosByTxid = new Map();
     for (const v of spent) {
-        // Prefer arkTxId over settledBy to avoid duplicates
-        // A vtxo should only be grouped once
-        const groupKey = v.arkTxId || v.settledBy;
-        if (!groupKey) {
+        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) {
             continue;
         }
-        if (!vtxosByTxid.has(groupKey)) {
-            vtxosByTxid.set(groupKey, []);
+        if (!vtxosByTxid.has(v.arkTxId)) {
+            vtxosByTxid.set(v.arkTxId, []);
         }
-        const currentVtxos = vtxosByTxid.get(groupKey);
-        vtxosByTxid.set(groupKey, [...currentVtxos, v]);
+        const currentVtxos = vtxosByTxid.get(v.arkTxId);
+        vtxosByTxid.set(v.arkTxId, [...currentVtxos, v]);
     }
     for (const [sb, vtxos] of vtxosByTxid) {
         const resultedVtxos = findVtxosResultedFromTxid([...spendable, ...spent], sb);
@@ -91,18 +85,16 @@ function vtxosToTxs(spendable, spent, boardingBatchTxids) {
         }
         const vtxo = getVtxo(resultedVtxos, vtxos);
         const txKey = {
-            commitmentTxid: vtxo.virtualStatus.commitmentTxIds?.[0] || "",
+            commitmentTxid: "",
             boardingTxid: "",
             arkTxid: "",
         };
-        // 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;
+        if (vtxo.virtualStatus.state === "preconfirmed") {
+            txKey.arkTxid = resultedAmount === 0 ? vtxo.arkTxId : vtxo.txid;
         }
-        else if (vtxo.virtualStatus.state === "preconfirmed") {
-            txKey.arkTxid = vtxo.txid;
+        else {
+            txKey.commitmentTxid =
+                vtxo.virtualStatus.commitmentTxIds?.[0] || "";
         }
         txs.push({
             key: txKey,

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

@@ -138,6 +138,15 @@ class Worker {
             scripts: [script],
         });
         const vtxos = response.vtxos.map((vtxo) => (0, utils_1.extendVirtualCoin)(this.wallet, vtxo));
+        try {
+            // recover pending transactions
+            const { finalized, pending } = await this.wallet.finalizePendingTxs(vtxos.filter((vtxo) => vtxo.virtualStatus.state !== "swept" &&
+                vtxo.virtualStatus.state !== "settled"));
+            console.info(`Recovered ${finalized.length}/${pending.length} pending transactions: ${finalized.join(", ")}`);
+        }
+        catch (error) {
+            console.error("Error recovering pending transactions:", error);
+        }
         // Get wallet address and save vtxos using unified repository
         const address = await this.wallet.getAddress();
         await this.walletRepository.saveVtxos(address, vtxos);

package/dist/cjs/wallet/wallet.js

@@ -62,6 +62,7 @@ const inMemory_1 = require("../storage/inMemory");
 const walletRepository_1 = require("../repositories/walletRepository");
 const contractRepository_1 = require("../repositories/contractRepository");
 const utils_1 = require("./utils");
+const errors_1 = require("../providers/errors");
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
  * The wallet does not store any data locally and relies on Ark and onchain
@@ -589,7 +590,7 @@ class Wallet {
             this.makeRegisterIntentSignature(params.inputs, outputs, onchainOutputIndexes, signingPublicKeys),
             this.makeDeleteIntentSignature(params.inputs),
         ]);
-        const intentId = await this.arkProvider.registerIntent(intent);
+        const intentId = await this.safeRegisterIntent(intent);
         const abortController = new AbortController();
         // listen to settlement events
         try {
@@ -741,7 +742,9 @@ class Wallet {
                 // delete the intent to not be stuck in the queue
                 await this.arkProvider.deleteIntent(deleteIntent);
             }
-            catch { }
+            catch (error) {
+                console.error("failed to delete intent: ", error);
+            }
             throw error;
         }
         throw new Error("Settlement failed");
@@ -956,6 +959,27 @@ class Wallet {
                 : undefined);
         }
     }
+    async safeRegisterIntent(intent) {
+        try {
+            return this.arkProvider.registerIntent(intent);
+        }
+        catch (error) {
+            // catch the "already registered by another intent" error
+            if (error instanceof errors_1.ArkError &&
+                error.code === 0 &&
+                error.message.includes("duplicated input")) {
+                // delete all intents spending one of the wallet coins
+                const allSpendableCoins = await this.getVtxos({
+                    withRecoverable: true,
+                });
+                const deleteIntent = await this.makeDeleteIntentSignature(allSpendableCoins);
+                await this.arkProvider.deleteIntent(deleteIntent);
+                // try again
+                return this.arkProvider.registerIntent(intent);
+            }
+            throw error;
+        }
+    }
     async makeRegisterIntentSignature(coins, outputs, onchainOutputsIndexes, cosignerPubKeys) {
         const inputs = this.prepareIntentProofInputs(coins);
         const message = {
@@ -987,6 +1011,67 @@ class Wallet {
             message: encodedMessage,
         };
     }
+    async makeGetPendingTxIntentSignature(vtxos) {
+        const inputs = this.prepareIntentProofInputs(vtxos);
+        const message = {
+            type: "get-pending-tx",
+            expire_at: 0,
+        };
+        const encodedMessage = JSON.stringify(message, null, 0);
+        const proof = intent_1.Intent.create(encodedMessage, inputs, []);
+        const signedProof = await this.identity.sign(proof);
+        return {
+            proof: base_1.base64.encode(signedProof.toPSBT()),
+            message: encodedMessage,
+        };
+    }
+    /**
+     * Finalizes pending transactions by retrieving them from the server and finalizing each one.
+     * @param vtxos - Optional list of VTXOs to use instead of retrieving them from the server
+     * @returns Array of transaction IDs that were finalized
+     */
+    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 = [base_1.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) {
+                return { finalized: [], pending: [] };
+            }
+            vtxos = fetchedVtxos.map((v) => (0, utils_1.extendVirtualCoin)(this, v));
+        }
+        const finalized = [];
+        const pending = [];
+        for (let i = 0; i < vtxos.length; i += MAX_INPUTS_PER_INTENT) {
+            const batch = vtxos.slice(i, i + MAX_INPUTS_PER_INTENT);
+            const intent = await this.makeGetPendingTxIntentSignature(batch);
+            const pendingTxs = await this.arkProvider.getPendingTxs(intent);
+            // finalize each transaction by signing the checkpoints
+            for (const pendingTx of pendingTxs) {
+                pending.push(pendingTx.arkTxid);
+                try {
+                    // sign the checkpoints
+                    const finalCheckpoints = await Promise.all(pendingTx.signedCheckpointTxs.map(async (c) => {
+                        const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(c));
+                        const signedCheckpoint = await this.identity.sign(tx);
+                        return base_1.base64.encode(signedCheckpoint.toPSBT());
+                    }));
+                    await this.arkProvider.finalizeTx(pendingTx.arkTxid, finalCheckpoints);
+                    finalized.push(pendingTx.arkTxid);
+                }
+                catch (error) {
+                    console.error(`Failed to finalize transaction ${pendingTx.arkTxid}:`, error);
+                    // continue with other transactions even if one fails
+                }
+            }
+        }
+        return { finalized, pending };
+    }
     prepareIntentProofInputs(coins) {
         const inputs = [];
         for (const input of coins) {

package/dist/esm/utils/transactionHistory.js

@@ -11,10 +11,6 @@ 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" &&
@@ -22,16 +18,6 @@ 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);
@@ -45,7 +31,7 @@ export function vtxosToTxs(spendable, spent, boardingBatchTxids) {
             continue; // settlement or change, ignore
         }
         const txKey = {
-            commitmentTxid: vtxo.spentBy || "",
+            commitmentTxid: "",
             boardingTxid: "",
             arkTxid: "",
         };
@@ -56,6 +42,10 @@ export function vtxosToTxs(spendable, spent, boardingBatchTxids) {
                 settled = true;
             }
         }
+        else {
+            txKey.commitmentTxid =
+                vtxo.virtualStatus.commitmentTxIds?.[0] || "";
+        }
         txs.push({
             key: txKey,
             amount: vtxo.value - settleAmount - spentAmount,
@@ -67,17 +57,21 @@ export function vtxosToTxs(spendable, spent, boardingBatchTxids) {
     // vtxos by settled by or ark txid
     const vtxosByTxid = new Map();
     for (const v of spent) {
-        // Prefer arkTxId over settledBy to avoid duplicates
-        // A vtxo should only be grouped once
-        const groupKey = v.arkTxId || v.settledBy;
-        if (!groupKey) {
+        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) {
             continue;
         }
-        if (!vtxosByTxid.has(groupKey)) {
-            vtxosByTxid.set(groupKey, []);
+        if (!vtxosByTxid.has(v.arkTxId)) {
+            vtxosByTxid.set(v.arkTxId, []);
         }
-        const currentVtxos = vtxosByTxid.get(groupKey);
-        vtxosByTxid.set(groupKey, [...currentVtxos, v]);
+        const currentVtxos = vtxosByTxid.get(v.arkTxId);
+        vtxosByTxid.set(v.arkTxId, [...currentVtxos, v]);
     }
     for (const [sb, vtxos] of vtxosByTxid) {
         const resultedVtxos = findVtxosResultedFromTxid([...spendable, ...spent], sb);
@@ -88,18 +82,16 @@ export function vtxosToTxs(spendable, spent, boardingBatchTxids) {
         }
         const vtxo = getVtxo(resultedVtxos, vtxos);
         const txKey = {
-            commitmentTxid: vtxo.virtualStatus.commitmentTxIds?.[0] || "",
+            commitmentTxid: "",
             boardingTxid: "",
             arkTxid: "",
         };
-        // 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;
+        if (vtxo.virtualStatus.state === "preconfirmed") {
+            txKey.arkTxid = resultedAmount === 0 ? vtxo.arkTxId : vtxo.txid;
         }
-        else if (vtxo.virtualStatus.state === "preconfirmed") {
-            txKey.arkTxid = vtxo.txid;
+        else {
+            txKey.commitmentTxid =
+                vtxo.virtualStatus.commitmentTxIds?.[0] || "";
         }
         txs.push({
             key: txKey,

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

@@ -135,6 +135,15 @@ export class Worker {
             scripts: [script],
         });
         const vtxos = response.vtxos.map((vtxo) => extendVirtualCoin(this.wallet, vtxo));
+        try {
+            // recover pending transactions
+            const { finalized, pending } = await this.wallet.finalizePendingTxs(vtxos.filter((vtxo) => vtxo.virtualStatus.state !== "swept" &&
+                vtxo.virtualStatus.state !== "settled"));
+            console.info(`Recovered ${finalized.length}/${pending.length} pending transactions: ${finalized.join(", ")}`);
+        }
+        catch (error) {
+            console.error("Error recovering pending transactions:", error);
+        }
         // Get wallet address and save vtxos using unified repository
         const address = await this.wallet.getAddress();
         await this.walletRepository.saveVtxos(address, vtxos);

package/dist/esm/wallet/wallet.js

@@ -25,6 +25,7 @@ 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 { ArkError } from '../providers/errors.js';
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
  * The wallet does not store any data locally and relies on Ark and onchain
@@ -552,7 +553,7 @@ export class Wallet {
             this.makeRegisterIntentSignature(params.inputs, outputs, onchainOutputIndexes, signingPublicKeys),
             this.makeDeleteIntentSignature(params.inputs),
         ]);
-        const intentId = await this.arkProvider.registerIntent(intent);
+        const intentId = await this.safeRegisterIntent(intent);
         const abortController = new AbortController();
         // listen to settlement events
         try {
@@ -704,7 +705,9 @@ export class Wallet {
                 // delete the intent to not be stuck in the queue
                 await this.arkProvider.deleteIntent(deleteIntent);
             }
-            catch { }
+            catch (error) {
+                console.error("failed to delete intent: ", error);
+            }
             throw error;
         }
         throw new Error("Settlement failed");
@@ -919,6 +922,27 @@ export class Wallet {
                 : undefined);
         }
     }
+    async safeRegisterIntent(intent) {
+        try {
+            return this.arkProvider.registerIntent(intent);
+        }
+        catch (error) {
+            // catch the "already registered by another intent" error
+            if (error instanceof ArkError &&
+                error.code === 0 &&
+                error.message.includes("duplicated input")) {
+                // delete all intents spending one of the wallet coins
+                const allSpendableCoins = await this.getVtxos({
+                    withRecoverable: true,
+                });
+                const deleteIntent = await this.makeDeleteIntentSignature(allSpendableCoins);
+                await this.arkProvider.deleteIntent(deleteIntent);
+                // try again
+                return this.arkProvider.registerIntent(intent);
+            }
+            throw error;
+        }
+    }
     async makeRegisterIntentSignature(coins, outputs, onchainOutputsIndexes, cosignerPubKeys) {
         const inputs = this.prepareIntentProofInputs(coins);
         const message = {
@@ -950,6 +974,67 @@ export class Wallet {
             message: encodedMessage,
         };
     }
+    async makeGetPendingTxIntentSignature(vtxos) {
+        const inputs = this.prepareIntentProofInputs(vtxos);
+        const message = {
+            type: "get-pending-tx",
+            expire_at: 0,
+        };
+        const encodedMessage = JSON.stringify(message, null, 0);
+        const proof = Intent.create(encodedMessage, inputs, []);
+        const signedProof = await this.identity.sign(proof);
+        return {
+            proof: base64.encode(signedProof.toPSBT()),
+            message: encodedMessage,
+        };
+    }
+    /**
+     * Finalizes pending transactions by retrieving them from the server and finalizing each one.
+     * @param vtxos - Optional list of VTXOs to use instead of retrieving them from the server
+     * @returns Array of transaction IDs that were finalized
+     */
+    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) {
+                return { finalized: [], pending: [] };
+            }
+            vtxos = fetchedVtxos.map((v) => extendVirtualCoin(this, v));
+        }
+        const finalized = [];
+        const pending = [];
+        for (let i = 0; i < vtxos.length; i += MAX_INPUTS_PER_INTENT) {
+            const batch = vtxos.slice(i, i + MAX_INPUTS_PER_INTENT);
+            const intent = await this.makeGetPendingTxIntentSignature(batch);
+            const pendingTxs = await this.arkProvider.getPendingTxs(intent);
+            // finalize each transaction by signing the checkpoints
+            for (const pendingTx of pendingTxs) {
+                pending.push(pendingTx.arkTxid);
+                try {
+                    // sign the checkpoints
+                    const finalCheckpoints = await Promise.all(pendingTx.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(pendingTx.arkTxid, finalCheckpoints);
+                    finalized.push(pendingTx.arkTxid);
+                }
+                catch (error) {
+                    console.error(`Failed to finalize transaction ${pendingTx.arkTxid}:`, error);
+                    // continue with other transactions even if one fails
+                }
+            }
+        }
+        return { finalized, pending };
+    }
     prepareIntentProofInputs(coins) {
         const inputs = [];
         for (const input of coins) {

package/dist/types/wallet/wallet.d.ts

@@ -94,8 +94,19 @@ export declare class Wallet implements IWallet {
     private handleSettlementSigningEvent;
     private handleSettlementTreeNoncesEvent;
     private handleSettlementFinalizationEvent;
+    safeRegisterIntent(intent: SignedIntent): Promise<string>;
     makeRegisterIntentSignature(coins: ExtendedCoin[], outputs: TransactionOutput[], onchainOutputsIndexes: number[], cosignerPubKeys: string[]): Promise<SignedIntent>;
     makeDeleteIntentSignature(coins: ExtendedCoin[]): Promise<SignedIntent>;
+    makeGetPendingTxIntentSignature(vtxos: ExtendedVirtualCoin[]): Promise<SignedIntent>;
+    /**
+     * Finalizes pending transactions by retrieving them from the server and finalizing each one.
+     * @param vtxos - Optional list of VTXOs to use instead of retrieving them from the server
+     * @returns Array of transaction IDs that were finalized
+     */
+    finalizePendingTxs(vtxos?: ExtendedVirtualCoin[]): Promise<{
+        finalized: string[];
+        pending: string[];
+    }>;
     private prepareIntentProofInputs;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Bitcoin wallet SDK with Taproot and Ark integration",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -63,8 +63,8 @@
     "@types/node": "24.3.1",
     "@vitest/coverage-v8": "3.2.4",
     "esbuild": "^0.25.9",
-    "eventsource": "4.0.0",
     "expo": "~52.0.47",
+    "eventsource": "4.0.0",
     "glob": "11.0.3",
     "husky": "9.1.7",
     "prettier": "3.6.2",