@arkade-os/sdk 0.3.7 → 0.3.8

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

@@ -1011,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/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

@@ -974,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

@@ -97,6 +97,16 @@ export declare class Wallet implements IWallet {
     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.7",
+  "version": "0.3.8",
   "description": "Bitcoin wallet SDK with Taproot and Ark integration",
   "type": "module",
   "main": "./dist/cjs/index.js",