@arkade-os/sdk 0.4.7 → 0.4.9

package/dist/esm/wallet/serviceWorker/wallet-message-handler.js

@@ -1,6 +1,25 @@
 import { RestIndexerProvider } from '../../providers/indexer.js';
 import { isExpired, isRecoverable, isSpendable, isSubdust, } from '../index.js';
 import { extendCoin, extendVirtualCoin } from '../utils.js';
+import { buildTransactionHistory } from '../../utils/transactionHistory.js';
+export class WalletNotInitializedError extends Error {
+    constructor() {
+        super("Wallet handler not initialized");
+        this.name = "WalletNotInitializedError";
+    }
+}
+export class ReadonlyWalletError extends Error {
+    constructor() {
+        super("Read-only wallet: operation requires signing");
+        this.name = "ReadonlyWalletError";
+    }
+}
+export class DelegatorNotConfiguredError extends Error {
+    constructor() {
+        super("Delegator not configured");
+        this.name = "DelegatorNotConfiguredError";
+    }
+}
 export const DEFAULT_MESSAGE_TAG = "WALLET_UPDATER";
 export class WalletMessageHandler {
     /**
@@ -21,7 +40,31 @@ export class WalletMessageHandler {
         this.walletRepository = repositories.walletRepository;
     }
     async stop() {
-        // optional cleanup and persistence
+        if (this.incomingFundsSubscription) {
+            this.incomingFundsSubscription();
+            this.incomingFundsSubscription = undefined;
+        }
+        if (this.contractEventsSubscription) {
+            this.contractEventsSubscription();
+            this.contractEventsSubscription = undefined;
+        }
+        // Dispose the wallet to stop VtxoManager background tasks
+        // (auto-renewal, boarding UTXO polling) and ContractWatcher.
+        try {
+            if (this.wallet) {
+                await this.wallet.dispose();
+            }
+            else if (this.readonlyWallet) {
+                await this.readonlyWallet.dispose();
+            }
+        }
+        catch (_) {
+            // best-effort teardown
+        }
+        this.wallet = undefined;
+        this.readonlyWallet = undefined;
+        this.arkProvider = undefined;
+        this.indexerProvider = undefined;
     }
     async tick(_now) {
         const results = await Promise.allSettled(this.onNextTick.map((fn) => fn()));
@@ -44,7 +87,7 @@ export class WalletMessageHandler {
     }
     requireWallet() {
         if (!this.wallet) {
-            throw new Error("Read-only wallet: operation requires signing");
+            throw new ReadonlyWalletError();
         }
         return this.wallet;
     }
@@ -66,7 +109,7 @@ export class WalletMessageHandler {
         if (!this.readonlyWallet) {
             return this.tagged({
                 id,
-                error: new Error("Wallet handler not initialized"),
+                error: new WalletNotInitializedError(),
             });
         }
         try {
@@ -127,7 +170,8 @@ export class WalletMessageHandler {
                     });
                 }
                 case "GET_TRANSACTION_HISTORY": {
-                    const transactions = await this.readonlyWallet.getTransactionHistory();
+                    const allVtxos = await this.getVtxosFromRepo();
+                    const transactions = (await this.buildTransactionHistoryFromCache(allVtxos)) ?? [];
                     return this.tagged({
                         id,
                         type: "TRANSACTION_HISTORY",
@@ -154,7 +198,7 @@ export class WalletMessageHandler {
                     });
                 }
                 case "RELOAD_WALLET": {
-                    await this.onWalletInitialized();
+                    await this.reloadWallet();
                     return this.tagged({
                         id,
                         type: "RELOAD_SUCCESS",
@@ -240,6 +284,14 @@ export class WalletMessageHandler {
                         payload: { isWatching },
                     });
                 }
+                case "REFRESH_VTXOS": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    await manager.refreshVtxos();
+                    return this.tagged({
+                        id,
+                        type: "REFRESH_VTXOS_SUCCESS",
+                    });
+                }
                 case "SEND": {
                     const { recipients } = message.payload;
                     const txid = await this.wallet.send(...recipients);
@@ -294,7 +346,7 @@ export class WalletMessageHandler {
                     const wallet = this.requireWallet();
                     const delegatorManager = await wallet.getDelegatorManager();
                     if (!delegatorManager) {
-                        throw new Error("Delegator not configured");
+                        throw new DelegatorNotConfiguredError();
                     }
                     const info = await delegatorManager.getDelegateInfo();
                     return this.tagged({
@@ -303,6 +355,83 @@ export class WalletMessageHandler {
                         payload: { info },
                     });
                 }
+                case "RECOVER_VTXOS": {
+                    const wallet = this.requireWallet();
+                    const vtxoManager = await wallet.getVtxoManager();
+                    const txid = await vtxoManager.recoverVtxos((e) => {
+                        this.scheduleForNextTick(() => this.tagged({
+                            id,
+                            type: "RECOVER_VTXOS_EVENT",
+                            payload: e,
+                        }));
+                    });
+                    return this.tagged({
+                        id,
+                        type: "RECOVER_VTXOS_SUCCESS",
+                        payload: { txid },
+                    });
+                }
+                case "GET_RECOVERABLE_BALANCE": {
+                    const wallet = this.requireWallet();
+                    const vtxoManager = await wallet.getVtxoManager();
+                    const balance = await vtxoManager.getRecoverableBalance();
+                    return this.tagged({
+                        id,
+                        type: "RECOVERABLE_BALANCE",
+                        payload: {
+                            recoverable: balance.recoverable.toString(),
+                            subdust: balance.subdust.toString(),
+                            includesSubdust: balance.includesSubdust,
+                            vtxoCount: balance.vtxoCount,
+                        },
+                    });
+                }
+                case "GET_EXPIRING_VTXOS": {
+                    const wallet = this.requireWallet();
+                    const vtxoManager = await wallet.getVtxoManager();
+                    const vtxos = await vtxoManager.getExpiringVtxos(message.payload.thresholdMs);
+                    return this.tagged({
+                        id,
+                        type: "EXPIRING_VTXOS",
+                        payload: { vtxos },
+                    });
+                }
+                case "RENEW_VTXOS": {
+                    const wallet = this.requireWallet();
+                    const vtxoManager = await wallet.getVtxoManager();
+                    const txid = await vtxoManager.renewVtxos((e) => {
+                        this.scheduleForNextTick(() => this.tagged({
+                            id,
+                            type: "RENEW_VTXOS_EVENT",
+                            payload: e,
+                        }));
+                    });
+                    return this.tagged({
+                        id,
+                        type: "RENEW_VTXOS_SUCCESS",
+                        payload: { txid },
+                    });
+                }
+                case "GET_EXPIRED_BOARDING_UTXOS": {
+                    const wallet = this.requireWallet();
+                    const vtxoManager = await wallet.getVtxoManager();
+                    const utxos = await vtxoManager.getExpiredBoardingUtxos();
+                    return this.tagged({
+                        id,
+                        type: "EXPIRED_BOARDING_UTXOS",
+                        payload: { utxos },
+                    });
+                }
+                case "SWEEP_EXPIRED_BOARDING_UTXOS": {
+                    const wallet = this.requireWallet();
+                    const vtxoManager = await wallet.getVtxoManager();
+                    const txid = await vtxoManager.sweepExpiredBoardingUtxos();
+                    return this.tagged({
+                        id,
+                        type: "SWEEP_EXPIRED_BOARDING_UTXOS_SUCCESS",
+                        payload: { txid },
+                    });
+                }
                 default:
                     console.error("Unknown message type", message);
                     throw new Error("Unknown message");
@@ -319,10 +448,9 @@ export class WalletMessageHandler {
         await this.onWalletInitialized();
     }
     async handleGetBalance() {
-        const [boardingUtxos, spendableVtxos, sweptVtxos] = await Promise.all([
+        const [boardingUtxos, allVtxos] = await Promise.all([
             this.getAllBoardingUtxos(),
-            this.getSpendableVtxos(),
-            this.getSweptVtxos(),
+            this.getVtxosFromRepo(),
         ]);
         // boarding
         let confirmed = 0;
@@ -335,7 +463,9 @@ export class WalletMessageHandler {
                 unconfirmed += utxo.value;
             }
         }
-        // offchain
+        // offchain — split spendable vs swept from single repo read
+        const spendableVtxos = allVtxos.filter(isSpendable);
+        const sweptVtxos = allVtxos.filter((vtxo) => vtxo.virtualStatus.state === "swept");
         let settled = 0;
         let preconfirmed = 0;
         let recoverable = 0;
@@ -385,23 +515,12 @@ export class WalletMessageHandler {
         return this.readonlyWallet.getBoardingUtxos();
     }
     /**
-     * Get spendable vtxos for the current wallet address
+     * Get spendable vtxos from the repository
      */
     async getSpendableVtxos() {
-        if (!this.readonlyWallet)
-            return [];
-        const vtxos = await this.readonlyWallet.getVtxos();
+        const vtxos = await this.getVtxosFromRepo();
         return vtxos.filter(isSpendable);
     }
-    /**
-     * Get swept vtxos for the current wallet address
-     */
-    async getSweptVtxos() {
-        if (!this.readonlyWallet)
-            return [];
-        const vtxos = await this.readonlyWallet.getVtxos();
-        return vtxos.filter((vtxo) => vtxo.virtualStatus.state === "swept");
-    }
     async onWalletInitialized() {
         if (!this.readonlyWallet ||
             !this.arkProvider ||
@@ -409,10 +528,11 @@ export class WalletMessageHandler {
             !this.walletRepository) {
             return;
         }
-        // Get all wallet scripts (current + historical delegate/non-delegate)
-        const scripts = await this.readonlyWallet.getWalletScripts();
-        const response = await this.indexerProvider.getVtxos({ scripts });
-        const vtxos = response.vtxos.map((vtxo) => extendVirtualCoin(this.readonlyWallet, vtxo));
+        // Initialize contract manager FIRST — this populates the repository
+        // with full VTXO history for all contracts (one indexer call per contract)
+        await this.ensureContractEventBroadcasting();
+        // Read VTXOs from repository (now populated by contract manager)
+        const vtxos = await this.getVtxosFromRepo();
         if (this.wallet) {
             try {
                 // recover pending transactions if possible
@@ -424,15 +544,13 @@ export class WalletMessageHandler {
                 console.error("Error recovering pending transactions:", error);
             }
         }
-        // Get wallet address and save vtxos using unified repository
-        const address = await this.readonlyWallet.getAddress();
-        await this.walletRepository.saveVtxos(address, vtxos);
         // Fetch boarding utxos and save using unified repository
         const boardingAddress = await this.readonlyWallet.getBoardingAddress();
         const coins = await this.readonlyWallet.onchainProvider.getCoins(boardingAddress);
         await this.walletRepository.saveUtxos(boardingAddress, coins.map((utxo) => extendCoin(this.readonlyWallet, utxo)));
-        // Get transaction history to cache boarding txs
-        const txs = await this.readonlyWallet.getTransactionHistory();
+        // Build transaction history from cached VTXOs (no indexer call)
+        const address = await this.readonlyWallet.getAddress();
+        const txs = await this.buildTransactionHistoryFromCache(vtxos);
         if (txs)
             await this.walletRepository.saveTransactions(address, txs);
         // unsubscribe previous subscription if any
@@ -477,7 +595,28 @@ export class WalletMessageHandler {
                     }));
                 }
             });
-        await this.ensureContractEventBroadcasting();
+        // Eagerly start the VtxoManager so its background tasks (auto-renewal,
+        // boarding UTXO polling/sweep) run inside the service worker without
+        // waiting for a client to send a vtxo-manager message first.
+        if (this.wallet) {
+            try {
+                await this.wallet.getVtxoManager();
+            }
+            catch (error) {
+                console.error("Error starting VtxoManager:", error);
+            }
+        }
+    }
+    /**
+     * Force a full VTXO refresh from the indexer, then re-run bootstrap.
+     * Used by RELOAD_WALLET to ensure fresh data.
+     */
+    async reloadWallet() {
+        if (!this.readonlyWallet)
+            return;
+        const manager = await this.readonlyWallet.getContractManager();
+        await manager.refreshVtxos();
+        await this.onWalletInitialized();
     }
     async handleSettle(message) {
         const wallet = this.requireWallet();
@@ -520,7 +659,7 @@ export class WalletMessageHandler {
         const wallet = this.requireWallet();
         const delegatorManager = await wallet.getDelegatorManager();
         if (!delegatorManager) {
-            throw new Error("Delegator not configured");
+            throw new DelegatorNotConfiguredError();
         }
         const { vtxoOutpoints, destination, delegateAt } = message.payload;
         const allVtxos = await wallet.getVtxos();
@@ -547,7 +686,7 @@ export class WalletMessageHandler {
     }
     async handleGetVtxos(message) {
         if (!this.readonlyWallet) {
-            throw new Error("Wallet handler not initialized");
+            throw new WalletNotInitializedError();
         }
         const vtxos = await this.getSpendableVtxos();
         const dustAmount = this.readonlyWallet.dustAmount;
@@ -602,6 +741,77 @@ export class WalletMessageHandler {
         this.arkProvider = undefined;
         this.indexerProvider = undefined;
     }
+    /**
+     * Read all VTXOs from the repository, aggregated across all contract
+     * addresses and the wallet's primary address, with deduplication.
+     */
+    async getVtxosFromRepo() {
+        if (!this.walletRepository || !this.readonlyWallet)
+            return [];
+        const seen = new Set();
+        const allVtxos = [];
+        const addVtxos = (vtxos) => {
+            for (const vtxo of vtxos) {
+                const key = `${vtxo.txid}:${vtxo.vout}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    allVtxos.push(vtxo);
+                }
+            }
+        };
+        // Aggregate VTXOs from all contract addresses
+        const manager = await this.readonlyWallet.getContractManager();
+        const contracts = await manager.getContracts();
+        for (const contract of contracts) {
+            const vtxos = await this.walletRepository.getVtxos(contract.address);
+            addVtxos(vtxos);
+        }
+        // Also check the wallet's primary address
+        const walletAddress = await this.readonlyWallet.getAddress();
+        const walletVtxos = await this.walletRepository.getVtxos(walletAddress);
+        addVtxos(walletVtxos);
+        return allVtxos;
+    }
+    /**
+     * Build transaction history from cached VTXOs without hitting the indexer.
+     * Falls back to indexer only for uncached transaction timestamps.
+     */
+    async buildTransactionHistoryFromCache(vtxos) {
+        if (!this.readonlyWallet)
+            return null;
+        const { boardingTxs, commitmentsToIgnore } = await this.readonlyWallet.getBoardingTxs();
+        // Build a lookup for cached VTXO timestamps, keyed by txid.
+        // Multiple VTXOs can share a txid (different vouts) — we keep the
+        // earliest createdAt so the history ordering is stable.
+        const vtxoCreatedAt = new Map();
+        for (const vtxo of vtxos) {
+            const existing = vtxoCreatedAt.get(vtxo.txid);
+            const ts = vtxo.createdAt.getTime();
+            if (existing === undefined || ts < existing) {
+                vtxoCreatedAt.set(vtxo.txid, ts);
+            }
+        }
+        // getTxCreatedAt resolves the creation timestamp of a transaction.
+        // buildTransactionHistory calls this for spent-offchain VTXOs with
+        // no change outputs to determine the time of the sending tx.
+        // Returns undefined on miss so buildTransactionHistory uses its
+        // own fallback (vtxo.createdAt + 1) rather than epoch 0.
+        // The vout:0 lookup in the indexer fallback mirrors the pre-existing
+        // convention in ReadonlyWallet.getTransactionHistory().
+        const getTxCreatedAt = async (txid) => {
+            const cached = vtxoCreatedAt.get(txid);
+            if (cached !== undefined)
+                return cached;
+            if (this.indexerProvider) {
+                const res = await this.indexerProvider.getVtxos({
+                    outpoints: [{ txid, vout: 0 }],
+                });
+                return res.vtxos[0]?.createdAt.getTime();
+            }
+            return undefined;
+        };
+        return buildTransactionHistory(vtxos, boardingTxs, commitmentsToIgnore, getTxCreatedAt);
+    }
     async ensureContractEventBroadcasting() {
         if (!this.readonlyWallet)
             return;