@arkade-os/sdk 0.3.7 → 0.3.9

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

@@ -1,7 +1,7 @@
 /// <reference lib="webworker" />
-import { SingleKey } from '../../identity/singleKey.js';
-import { isRecoverable, isSpendable, isSubdust, } from '../index.js';
-import { Wallet } from '../wallet.js';
+import { ReadonlySingleKey, SingleKey } from '../../identity/singleKey.js';
+import { isExpired, isRecoverable, isSpendable, isSubdust, } from '../index.js';
+import { ReadonlyWallet, Wallet } from '../wallet.js';
 import { Request } from './request.js';
 import { Response } from './response.js';
 import { RestArkProvider } from '../../providers/ark.js';
@@ -12,9 +12,70 @@ import { IndexedDBStorageAdapter } from '../../storage/indexedDB.js';
 import { WalletRepositoryImpl, } from '../../repositories/walletRepository.js';
 import { extendCoin, extendVirtualCoin } from '../utils.js';
 import { DEFAULT_DB_NAME } from './utils.js';
+class ReadonlyHandler {
+    constructor(wallet) {
+        this.wallet = wallet;
+    }
+    get offchainTapscript() {
+        return this.wallet.offchainTapscript;
+    }
+    get boardingTapscript() {
+        return this.wallet.boardingTapscript;
+    }
+    get onchainProvider() {
+        return this.wallet.onchainProvider;
+    }
+    get dustAmount() {
+        return this.wallet.dustAmount;
+    }
+    get identity() {
+        return this.wallet.identity;
+    }
+    notifyIncomingFunds(...args) {
+        return this.wallet.notifyIncomingFunds(...args);
+    }
+    getAddress() {
+        return this.wallet.getAddress();
+    }
+    getBoardingAddress() {
+        return this.wallet.getBoardingAddress();
+    }
+    getBoardingTxs() {
+        return this.wallet.getBoardingTxs();
+    }
+    async handleReload(_) {
+        const pending = await this.wallet.fetchPendingTxs();
+        return { pending, finalized: [] };
+    }
+    async handleSettle(..._) {
+        return undefined;
+    }
+    async handleSendBitcoin(..._) {
+        return undefined;
+    }
+}
+class Handler extends ReadonlyHandler {
+    constructor(wallet) {
+        super(wallet);
+        this.wallet = wallet;
+    }
+    async handleReload(vtxos) {
+        return this.wallet.finalizePendingTxs(vtxos.filter((vtxo) => vtxo.virtualStatus.state !== "swept" &&
+            vtxo.virtualStatus.state !== "settled"));
+    }
+    async handleSettle(...args) {
+        return this.wallet.settle(...args);
+    }
+    async handleSendBitcoin(...args) {
+        return this.wallet.sendBitcoin(...args);
+    }
+}
 /**
- * Worker is a class letting to interact with ServiceWorkerWallet from the client
- * it aims to be run in a service worker context
+ * Worker is a class letting to interact with ServiceWorkerWallet and ServiceWorkerReadonlyWallet from
+ * the client; it aims to be run in a service worker context.
+ *
+ * The messages requiring a Wallet rather than a ReadonlyWallet result in no-op
+ * without errors.
  */
 export class Worker {
     constructor(dbName = DEFAULT_DB_NAME, dbVersion = 1, messageCallback = () => { }) {
@@ -28,9 +89,9 @@ export class Worker {
      * Get spendable vtxos for the current wallet address
      */
     async getSpendableVtxos() {
-        if (!this.wallet)
+        if (!this.handler)
             return [];
-        const address = await this.wallet.getAddress();
+        const address = await this.handler.getAddress();
         const allVtxos = await this.walletRepository.getVtxos(address);
         return allVtxos.filter(isSpendable);
     }
@@ -38,9 +99,9 @@ export class Worker {
      * Get swept vtxos for the current wallet address
      */
     async getSweptVtxos() {
-        if (!this.wallet)
+        if (!this.handler)
             return [];
-        const address = await this.wallet.getAddress();
+        const address = await this.handler.getAddress();
         const allVtxos = await this.walletRepository.getVtxos(address);
         return allVtxos.filter((vtxo) => vtxo.virtualStatus.state === "swept");
     }
@@ -48,9 +109,9 @@ export class Worker {
      * Get all vtxos categorized by type
      */
     async getAllVtxos() {
-        if (!this.wallet)
+        if (!this.handler)
             return { spendable: [], spent: [] };
-        const address = await this.wallet.getAddress();
+        const address = await this.handler.getAddress();
         const allVtxos = await this.walletRepository.getVtxos(address);
         return {
             spendable: allVtxos.filter(isSpendable),
@@ -61,17 +122,17 @@ export class Worker {
      * Get all boarding utxos from wallet repository
      */
     async getAllBoardingUtxos() {
-        if (!this.wallet)
+        if (!this.handler)
             return [];
-        const address = await this.wallet.getBoardingAddress();
+        const address = await this.handler.getBoardingAddress();
         return await this.walletRepository.getUtxos(address);
     }
     async getTransactionHistory() {
-        if (!this.wallet)
+        if (!this.handler)
             return [];
         let txs = [];
         try {
-            const { boardingTxs, commitmentsToIgnore: roundsToIgnore } = await this.wallet.getBoardingTxs();
+            const { boardingTxs, commitmentsToIgnore: roundsToIgnore } = await this.handler.getBoardingTxs();
             const { spendable, spent } = await this.getAllVtxos();
             // convert VTXOs to offchain transactions
             const offchainTxs = vtxosToTxs(spendable, spent, roundsToIgnore);
@@ -114,7 +175,7 @@ export class Worker {
         await this.storage.clear();
         // Reset in-memory caches by recreating the repository
         this.walletRepository = new WalletRepositoryImpl(this.storage);
-        this.wallet = undefined;
+        this.handler = undefined;
         this.arkProvider = undefined;
         this.indexerProvider = undefined;
     }
@@ -122,26 +183,34 @@ export class Worker {
         await this.onWalletInitialized();
     }
     async onWalletInitialized() {
-        if (!this.wallet ||
+        if (!this.handler ||
             !this.arkProvider ||
             !this.indexerProvider ||
-            !this.wallet.offchainTapscript ||
-            !this.wallet.boardingTapscript) {
+            !this.handler.offchainTapscript ||
+            !this.handler.boardingTapscript) {
             return;
         }
         // Get public key script and set the initial vtxos state
-        const script = hex.encode(this.wallet.offchainTapscript.pkScript);
+        const script = hex.encode(this.handler.offchainTapscript.pkScript);
         const response = await this.indexerProvider.getVtxos({
             scripts: [script],
         });
-        const vtxos = response.vtxos.map((vtxo) => extendVirtualCoin(this.wallet, vtxo));
+        const vtxos = response.vtxos.map((vtxo) => extendVirtualCoin(this.handler, vtxo));
+        try {
+            // recover pending transactions if possible
+            const { pending, finalized } = await this.handler.handleReload(vtxos);
+            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();
+        const address = await this.handler.getAddress();
         await this.walletRepository.saveVtxos(address, vtxos);
         // Fetch boarding utxos and save using unified repository
-        const boardingAddress = await this.wallet.getBoardingAddress();
-        const coins = await this.wallet.onchainProvider.getCoins(boardingAddress);
-        await this.walletRepository.saveUtxos(boardingAddress, coins.map((utxo) => extendCoin(this.wallet, utxo)));
+        const boardingAddress = await this.handler.getBoardingAddress();
+        const coins = await this.handler.onchainProvider.getCoins(boardingAddress);
+        await this.walletRepository.saveUtxos(boardingAddress, coins.map((utxo) => extendCoin(this.handler, utxo)));
         // Get transaction history to cache boarding txs
         const txs = await this.getTransactionHistory();
         if (txs)
@@ -150,13 +219,13 @@ export class Worker {
         if (this.incomingFundsSubscription)
             this.incomingFundsSubscription();
         // subscribe for incoming funds and notify all clients when new funds arrive
-        this.incomingFundsSubscription = await this.wallet.notifyIncomingFunds(async (funds) => {
+        this.incomingFundsSubscription = await this.handler.notifyIncomingFunds(async (funds) => {
             if (funds.type === "vtxo") {
                 const newVtxos = funds.newVtxos.length > 0
-                    ? funds.newVtxos.map((vtxo) => extendVirtualCoin(this.wallet, vtxo))
+                    ? funds.newVtxos.map((vtxo) => extendVirtualCoin(this.handler, vtxo))
                     : [];
                 const spentVtxos = funds.spentVtxos.length > 0
-                    ? funds.spentVtxos.map((vtxo) => extendVirtualCoin(this.wallet, vtxo))
+                    ? funds.spentVtxos.map((vtxo) => extendVirtualCoin(this.handler, vtxo))
                     : [];
                 if ([...newVtxos, ...spentVtxos].length === 0)
                     return;
@@ -169,8 +238,8 @@ export class Worker {
                 await this.sendMessageToAllClients(Response.vtxoUpdate(newVtxos, spentVtxos));
             }
             if (funds.type === "utxo") {
-                const utxos = funds.coins.map((utxo) => extendCoin(this.wallet, utxo));
-                const boardingAddress = await this.wallet?.getBoardingAddress();
+                const utxos = funds.coins.map((utxo) => extendCoin(this.handler, utxo));
+                const boardingAddress = await this.handler?.getBoardingAddress();
                 // save utxos using unified repository
                 await this.walletRepository.clearUtxos(boardingAddress);
                 await this.walletRepository.saveUtxos(boardingAddress, utxos);
@@ -186,31 +255,46 @@ export class Worker {
         }
     }
     async handleInitWallet(event) {
-        const message = event.data;
-        if (!Request.isInitWallet(message)) {
-            console.error("Invalid INIT_WALLET message format", message);
-            event.source?.postMessage(Response.error(message.id, "Invalid INIT_WALLET message format"));
-            return;
-        }
-        if (!message.privateKey) {
-            const err = "Missing privateKey";
-            event.source?.postMessage(Response.error(message.id, err));
-            console.error(err);
+        if (!Request.isInitWallet(event.data)) {
+            console.error("Invalid INIT_WALLET message format", event.data);
+            event.source?.postMessage(Response.error(event.data.id, "Invalid INIT_WALLET message format"));
             return;
         }
+        const message = event.data;
+        const { arkServerPublicKey, arkServerUrl } = message;
+        this.arkProvider = new RestArkProvider(arkServerUrl);
+        this.indexerProvider = new RestIndexerProvider(arkServerUrl);
         try {
-            const { arkServerPublicKey, arkServerUrl, privateKey } = message;
-            const identity = SingleKey.fromHex(privateKey);
-            this.arkProvider = new RestArkProvider(arkServerUrl);
-            this.indexerProvider = new RestIndexerProvider(arkServerUrl);
-            this.wallet = await Wallet.create({
-                identity,
-                arkServerUrl,
-                arkServerPublicKey,
-                storage: this.storage, // Use unified storage for wallet too
-            });
-            event.source?.postMessage(Response.walletInitialized(message.id));
-            await this.onWalletInitialized();
+            if ("privateKey" in message.key &&
+                typeof message.key.privateKey === "string") {
+                const { key: { privateKey }, } = message;
+                const identity = SingleKey.fromHex(privateKey);
+                const wallet = await Wallet.create({
+                    identity,
+                    arkServerUrl,
+                    arkServerPublicKey,
+                    storage: this.storage, // Use unified storage for wallet too
+                });
+                this.handler = new Handler(wallet);
+            }
+            else if ("publicKey" in message.key &&
+                typeof message.key.publicKey === "string") {
+                const { key: { publicKey }, } = message;
+                const identity = ReadonlySingleKey.fromPublicKey(hex.decode(publicKey));
+                const wallet = await ReadonlyWallet.create({
+                    identity,
+                    arkServerUrl,
+                    arkServerPublicKey,
+                    storage: this.storage, // Use unified storage for wallet too
+                });
+                this.handler = new ReadonlyHandler(wallet);
+            }
+            else {
+                const err = "Missing privateKey or publicKey in key object";
+                event.source?.postMessage(Response.error(message.id, err));
+                console.error(err);
+                return;
+            }
         }
         catch (error) {
             console.error("Error initializing wallet:", error);
@@ -218,7 +302,10 @@ export class Worker {
                 ? error.message
                 : "Unknown error occurred";
             event.source?.postMessage(Response.error(message.id, errorMessage));
+            return;
         }
+        event.source?.postMessage(Response.walletInitialized(message.id));
+        await this.onWalletInitialized();
     }
     async handleSettle(event) {
         const message = event.data;
@@ -228,15 +315,20 @@ export class Worker {
             return;
         }
         try {
-            if (!this.wallet) {
+            if (!this.handler) {
                 console.error("Wallet not initialized");
                 event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
                 return;
             }
-            const txid = await this.wallet.settle(message.params, (e) => {
+            const txid = await this.handler.handleSettle(message.params, (e) => {
                 event.source?.postMessage(Response.settleEvent(message.id, e));
             });
-            event.source?.postMessage(Response.settleSuccess(message.id, txid));
+            if (txid) {
+                event.source?.postMessage(Response.settleSuccess(message.id, txid));
+            }
+            else {
+                event.source?.postMessage(Response.error(message.id, "Operation not supported in readonly mode"));
+            }
         }
         catch (error) {
             console.error("Error settling:", error);
@@ -253,14 +345,19 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid SEND_BITCOIN message format"));
             return;
         }
-        if (!this.wallet) {
+        if (!this.handler) {
             console.error("Wallet not initialized");
             event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
             return;
         }
         try {
-            const txid = await this.wallet.sendBitcoin(message.params);
-            event.source?.postMessage(Response.sendBitcoinSuccess(message.id, txid));
+            const txid = await this.handler.handleSendBitcoin(message.params);
+            if (txid) {
+                event.source?.postMessage(Response.sendBitcoinSuccess(message.id, txid));
+            }
+            else {
+                event.source?.postMessage(Response.error(message.id, "Operation not supported in readonly mode"));
+            }
         }
         catch (error) {
             console.error("Error sending bitcoin:", error);
@@ -277,13 +374,13 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid GET_ADDRESS message format"));
             return;
         }
-        if (!this.wallet) {
+        if (!this.handler) {
             console.error("Wallet not initialized");
             event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
             return;
         }
         try {
-            const address = await this.wallet.getAddress();
+            const address = await this.handler.getAddress();
             event.source?.postMessage(Response.address(message.id, address));
         }
         catch (error) {
@@ -301,13 +398,13 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid GET_BOARDING_ADDRESS message format"));
             return;
         }
-        if (!this.wallet) {
+        if (!this.handler) {
             console.error("Wallet not initialized");
             event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
             return;
         }
         try {
-            const address = await this.wallet.getBoardingAddress();
+            const address = await this.handler.getBoardingAddress();
             event.source?.postMessage(Response.boardingAddress(message.id, address));
         }
         catch (error) {
@@ -325,7 +422,7 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid GET_BALANCE message format"));
             return;
         }
-        if (!this.wallet) {
+        if (!this.handler) {
             console.error("Wallet not initialized");
             event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
             return;
@@ -394,14 +491,14 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid GET_VTXOS message format"));
             return;
         }
-        if (!this.wallet) {
+        if (!this.handler) {
             console.error("Wallet not initialized");
             event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
             return;
         }
         try {
             const vtxos = await this.getSpendableVtxos();
-            const dustAmount = this.wallet.dustAmount;
+            const dustAmount = this.handler.dustAmount;
             const includeRecoverable = message.filter?.withRecoverable ?? false;
             const filteredVtxos = includeRecoverable
                 ? vtxos
@@ -412,6 +509,9 @@ export class Worker {
                     if (isRecoverable(v)) {
                         return false;
                     }
+                    if (isExpired(v)) {
+                        return false;
+                    }
                     return true;
                 });
             event.source?.postMessage(Response.vtxos(message.id, filteredVtxos));
@@ -431,7 +531,7 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid GET_BOARDING_UTXOS message format"));
             return;
         }
-        if (!this.wallet) {
+        if (!this.handler) {
             console.error("Wallet not initialized");
             event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
             return;
@@ -455,7 +555,7 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid GET_TRANSACTION_HISTORY message format"));
             return;
         }
-        if (!this.wallet) {
+        if (!this.handler) {
             console.error("Wallet not initialized");
             event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
             return;
@@ -479,10 +579,10 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid GET_STATUS message format"));
             return;
         }
-        const pubKey = this.wallet
-            ? await this.wallet.identity.xOnlyPublicKey()
+        const pubKey = this.handler
+            ? await this.handler.identity.xOnlyPublicKey()
             : undefined;
-        event.source?.postMessage(Response.walletStatus(message.id, this.wallet !== undefined, pubKey));
+        event.source?.postMessage(Response.walletStatus(message.id, this.handler !== undefined, pubKey));
     }
     async handleMessage(event) {
         this.messageCallback(event);
@@ -561,7 +661,7 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid RELOAD_WALLET message format"));
             return;
         }
-        if (!this.wallet) {
+        if (!this.handler) {
             console.error("Wallet not initialized");
             event.source?.postMessage(Response.walletReloaded(message.id, false));
             return;

package/dist/esm/wallet/utils.js

@@ -2,7 +2,7 @@ export function extendVirtualCoin(wallet, vtxo) {
     return {
         ...vtxo,
         forfeitTapLeafScript: wallet.offchainTapscript.forfeit(),
-        intentTapLeafScript: wallet.offchainTapscript.exit(),
+        intentTapLeafScript: wallet.offchainTapscript.forfeit(),
         tapTree: wallet.offchainTapscript.encode(),
     };
 }
@@ -10,7 +10,7 @@ export function extendCoin(wallet, utxo) {
     return {
         ...utxo,
         forfeitTapLeafScript: wallet.boardingTapscript.forfeit(),
-        intentTapLeafScript: wallet.boardingTapscript.exit(),
+        intentTapLeafScript: wallet.boardingTapscript.forfeit(),
         tapTree: wallet.boardingTapscript.encode(),
     };
 }

package/dist/esm/wallet/vtxo-manager.js

@@ -1,4 +1,4 @@
-import { isRecoverable, isSubdust } from './index.js';
+import { isExpired, isRecoverable, isSpendable, isSubdust, } from './index.js';
 export const DEFAULT_THRESHOLD_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
 /**
  * Default renewal configuration values
@@ -26,6 +26,10 @@ function getRecoverableVtxos(vtxos, dustAmount) {
         if (isRecoverable(vtxo)) {
             return true;
         }
+        // also include vtxos that are not swept but expired
+        if (isSpendable(vtxo) && isExpired(vtxo)) {
+            return true;
+        }
         // Recover preconfirmed subdust to consolidate small amounts
         if (vtxo.virtualStatus.state === "preconfirmed" &&
             isSubdust(vtxo, dustAmount)) {
@@ -100,6 +104,7 @@ export function isVtxoExpiringSoon(vtxo, thresholdMs // in milliseconds
 export function getExpiringAndRecoverableVtxos(vtxos, thresholdMs, dustAmount) {
     return vtxos.filter((vtxo) => isVtxoExpiringSoon(vtxo, thresholdMs) ||
         isRecoverable(vtxo) ||
+        (isSpendable(vtxo) && isExpired(vtxo)) ||
         isSubdust(vtxo, dustAmount));
 }
 /**