@arkade-os/sdk 0.1.4 → 0.2.0

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

@@ -1,12 +1,37 @@
 import { Response } from './response.js';
-import { hex } from "@scure/base";
+import { base64, hex } from "@scure/base";
+import { SingleKey } from '../../identity/singleKey.js';
+import { TreeSignerSession } from '../../tree/signingSession.js';
+import { Transaction } from "@scure/btc-signer";
 class UnexpectedResponseError extends Error {
     constructor(response) {
         super(`Unexpected response type. Got: ${JSON.stringify(response, null, 2)}`);
         this.name = "UnexpectedResponseError";
     }
 }
-// ServiceWorkerWallet is a wallet that uses a service worker as "backend" to handle the wallet logic
+/**
+ * Service Worker-based wallet implementation for browser environments.
+ *
+ * This wallet uses a service worker as a backend to handle wallet logic,
+ * providing secure key storage and transaction signing in web applications.
+ * The service worker runs in a separate thread and can persist data between
+ * browser sessions.
+ *
+ * @example
+ * ```typescript
+ * // Create and initialize the service worker wallet
+ * const serviceWorker = await setupServiceWorker("/service-worker.js");
+ * const wallet = new ServiceWorkerWallet(serviceWorker);
+ * await wallet.init({
+ *   privateKey: 'your_private_key_hex',
+ *   arkServerUrl: 'https://ark.example.com'
+ * });
+ *
+ * // Use like any other wallet
+ * const address = await wallet.getAddress();
+ * const balance = await wallet.getBalance();
+ * ```
+ */
 export class ServiceWorkerWallet {
     constructor(serviceWorker) {
         this.serviceWorker = serviceWorker;
@@ -41,11 +66,14 @@ export class ServiceWorkerWallet {
             type: "INIT_WALLET",
             id: getRandomId(),
             privateKey: config.privateKey,
-            network: config.network,
-            arkServerUrl: config.arkServerUrl || "",
+            arkServerUrl: config.arkServerUrl,
             arkServerPublicKey: config.arkServerPublicKey,
         };
         await this.sendMessage(message);
+        const privKeyBytes = hex.decode(config.privateKey);
+        // cache the identity xOnlyPublicKey
+        this.cachedXOnlyPublicKey =
+            SingleKey.fromPrivateKey(privKeyBytes).xOnlyPublicKey();
     }
     async clear() {
         const message = {
@@ -53,6 +81,8 @@ export class ServiceWorkerWallet {
             id: getRandomId(),
         };
         await this.sendMessage(message);
+        // clear the cached xOnlyPublicKey
+        this.cachedXOnlyPublicKey = undefined;
     }
     // send a message and wait for a response
     async sendMessage(message) {
@@ -86,7 +116,7 @@ export class ServiceWorkerWallet {
         try {
             const response = await this.sendMessage(message);
             if (Response.isAddress(response)) {
-                return response.addresses;
+                return response.address;
             }
             throw new UnexpectedResponseError(response);
         }
@@ -94,20 +124,20 @@ export class ServiceWorkerWallet {
             throw new Error(`Failed to get address: ${error}`);
         }
     }
-    async getAddressInfo() {
+    async getBoardingAddress() {
         const message = {
-            type: "GET_ADDRESS_INFO",
+            type: "GET_BOARDING_ADDRESS",
             id: getRandomId(),
         };
         try {
             const response = await this.sendMessage(message);
-            if (Response.isAddressInfo(response)) {
-                return response.addressInfo;
+            if (Response.isBoardingAddress(response)) {
+                return response.address;
             }
             throw new UnexpectedResponseError(response);
         }
         catch (error) {
-            throw new Error(`Failed to get address info: ${error}`);
+            throw new Error(`Failed to get boarding address: ${error}`);
         }
     }
     async getBalance() {
@@ -126,26 +156,11 @@ export class ServiceWorkerWallet {
             throw new Error(`Failed to get balance: ${error}`);
         }
     }
-    async getCoins() {
-        const message = {
-            type: "GET_COINS",
-            id: getRandomId(),
-        };
-        try {
-            const response = await this.sendMessage(message);
-            if (Response.isCoins(response)) {
-                return response.coins;
-            }
-            throw new UnexpectedResponseError(response);
-        }
-        catch (error) {
-            throw new Error(`Failed to get coins: ${error}`);
-        }
-    }
-    async getVtxos() {
+    async getVtxos(filter) {
         const message = {
             type: "GET_VTXOS",
             id: getRandomId(),
+            filter,
         };
         try {
             const response = await this.sendMessage(message);
@@ -174,11 +189,10 @@ export class ServiceWorkerWallet {
             throw new Error(`Failed to get boarding UTXOs: ${error}`);
         }
     }
-    async sendBitcoin(params, zeroFee) {
+    async sendBitcoin(params) {
         const message = {
             type: "SEND_BITCOIN",
             params,
-            zeroFee,
             id: getRandomId(),
         };
         try {
@@ -245,21 +259,31 @@ export class ServiceWorkerWallet {
             throw new Error(`Failed to get transaction history: ${error}`);
         }
     }
-    async exit(outpoints) {
+    xOnlyPublicKey() {
+        if (!this.cachedXOnlyPublicKey) {
+            throw new Error("Wallet not initialized");
+        }
+        return this.cachedXOnlyPublicKey;
+    }
+    signerSession() {
+        return TreeSignerSession.random();
+    }
+    async sign(tx, inputIndexes) {
         const message = {
-            type: "EXIT",
-            outpoints,
+            type: "SIGN",
+            tx: base64.encode(tx.toPSBT()),
+            inputIndexes,
             id: getRandomId(),
         };
         try {
             const response = await this.sendMessage(message);
-            if (response.type === "EXIT_SUCCESS") {
-                return;
+            if (Response.isSignSuccess(response)) {
+                return Transaction.fromPSBT(base64.decode(response.tx));
             }
             throw new UnexpectedResponseError(response);
         }
         catch (error) {
-            throw new Error(`Failed to exit: ${error}`);
+            throw new Error(`Failed to sign: ${error}`);
         }
     }
 }

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

@@ -1,14 +1,19 @@
 /// <reference lib="webworker" />
-import { InMemoryKey } from '../../identity/inMemoryKey.js';
+import { SingleKey } from '../../identity/singleKey.js';
+import { isSpendable, isSubdust } from '../index.js';
 import { Wallet } from '../wallet.js';
 import { Request } from './request.js';
 import { Response } from './response.js';
 import { RestArkProvider } from '../../providers/ark.js';
-import { DefaultVtxo } from '../../script/default.js';
 import { IndexedDBVtxoRepository } from './db/vtxo/idb.js';
 import { vtxosToTxs } from '../../utils/transactionHistory.js';
-// Worker is a class letting to interact with ServiceWorkerWallet from the client
-// it aims to be run in a service worker context
+import { RestIndexerProvider } from '../../providers/indexer.js';
+import { base64, hex } from "@scure/base";
+import { Transaction } from "@scure/btc-signer";
+/**
+ * Worker is a class letting to interact with ServiceWorkerWallet from the client
+ * it aims to be run in a service worker context
+ */
 export class Worker {
     constructor(vtxoRepository = new IndexedDBVtxoRepository(), messageCallback = () => { }) {
         this.vtxoRepository = vtxoRepository;
@@ -36,41 +41,48 @@ export class Worker {
         await this.vtxoRepository.close();
         this.wallet = undefined;
         this.arkProvider = undefined;
+        this.indexerProvider = undefined;
         this.vtxoSubscription = undefined;
     }
     async onWalletInitialized() {
         if (!this.wallet ||
             !this.arkProvider ||
+            !this.indexerProvider ||
             !this.wallet.offchainTapscript ||
             !this.wallet.boardingTapscript) {
             return;
         }
         // subscribe to address updates
-        const addressInfo = await this.wallet.getAddressInfo();
-        if (!addressInfo.offchain) {
-            return;
-        }
         await this.vtxoRepository.open();
-        // set the initial vtxos state
-        const { spendableVtxos, spentVtxos } = await this.arkProvider.getVirtualCoins(addressInfo.offchain.address);
         const encodedOffchainTapscript = this.wallet.offchainTapscript.encode();
         const forfeit = this.wallet.offchainTapscript.forfeit();
-        const vtxos = [...spendableVtxos, ...spentVtxos].map((vtxo) => ({
+        const exit = this.wallet.offchainTapscript.exit();
+        const script = hex.encode(this.wallet.offchainTapscript.pkScript);
+        // set the initial vtxos state
+        const response = await this.indexerProvider.getVtxos({
+            scripts: [script],
+        });
+        const vtxos = response.vtxos.map((vtxo) => ({
             ...vtxo,
-            tapLeafScript: forfeit,
-            scripts: encodedOffchainTapscript,
+            forfeitTapLeafScript: forfeit,
+            intentTapLeafScript: exit,
+            tapTree: encodedOffchainTapscript,
         }));
         await this.vtxoRepository.addOrUpdate(vtxos);
-        this.processVtxoSubscription(addressInfo.offchain);
+        this.processVtxoSubscription({
+            script,
+            vtxoScript: this.wallet.offchainTapscript,
+        });
     }
-    async processVtxoSubscription({ address, scripts, }) {
+    async processVtxoSubscription({ script, vtxoScript, }) {
         try {
-            const addressScripts = [...scripts.exit, ...scripts.forfeit];
-            const vtxoScript = DefaultVtxo.Script.decode(addressScripts);
-            const tapLeafScript = vtxoScript.findLeaf(scripts.forfeit[0]);
+            const forfeitTapLeafScript = vtxoScript.forfeit();
+            const intentTapLeafScript = vtxoScript.exit();
             const abortController = new AbortController();
-            const subscription = this.arkProvider.subscribeForAddress(address, abortController.signal);
+            const subscriptionId = await this.indexerProvider.subscribeForScripts([script]);
+            const subscription = this.indexerProvider.getSubscription(subscriptionId, abortController.signal);
             this.vtxoSubscription = abortController;
+            const tapTree = vtxoScript.encode();
             for await (const update of subscription) {
                 const vtxos = [...update.newVtxos, ...update.spentVtxos];
                 if (vtxos.length === 0) {
@@ -78,8 +90,9 @@ export class Worker {
                 }
                 const extendedVtxos = vtxos.map((vtxo) => ({
                     ...vtxo,
-                    tapLeafScript,
-                    scripts: addressScripts,
+                    forfeitTapLeafScript,
+                    intentTapLeafScript,
+                    tapTree,
                 }));
                 await this.vtxoRepository.addOrUpdate(extendedVtxos);
             }
@@ -103,9 +116,9 @@ export class Worker {
         }
         try {
             this.arkProvider = new RestArkProvider(message.arkServerUrl);
+            this.indexerProvider = new RestIndexerProvider(message.arkServerUrl);
             this.wallet = await Wallet.create({
-                network: message.network,
-                identity: InMemoryKey.fromHex(message.privateKey),
+                identity: SingleKey.fromHex(message.privateKey),
                 arkServerUrl: message.arkServerUrl,
                 arkServerPublicKey: message.arkServerPublicKey,
             });
@@ -159,7 +172,7 @@ export class Worker {
             return;
         }
         try {
-            const txid = await this.wallet.sendBitcoin(message.params, message.zeroFee);
+            const txid = await this.wallet.sendBitcoin(message.params);
             event.source?.postMessage(Response.sendBitcoinSuccess(message.id, txid));
         }
         catch (error) {
@@ -183,8 +196,8 @@ export class Worker {
             return;
         }
         try {
-            const addresses = await this.wallet.getAddress();
-            event.source?.postMessage(Response.addresses(message.id, addresses));
+            const address = await this.wallet.getAddress();
+            event.source?.postMessage(Response.address(message.id, address));
         }
         catch (error) {
             console.error("Error getting address:", error);
@@ -194,11 +207,11 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, errorMessage));
         }
     }
-    async handleGetAddressInfo(event) {
+    async handleGetBoardingAddress(event) {
         const message = event.data;
-        if (!Request.isGetAddressInfo(message)) {
-            console.error("Invalid GET_ADDRESS_INFO message format", message);
-            event.source?.postMessage(Response.error(message.id, "Invalid GET_ADDRESS_INFO message format"));
+        if (!Request.isGetBoardingAddress(message)) {
+            console.error("Invalid GET_BOARDING_ADDRESS message format", message);
+            event.source?.postMessage(Response.error(message.id, "Invalid GET_BOARDING_ADDRESS message format"));
             return;
         }
         if (!this.wallet) {
@@ -207,11 +220,11 @@ export class Worker {
             return;
         }
         try {
-            const addressInfo = await this.wallet.getAddressInfo();
-            event.source?.postMessage(Response.addressInfo(message.id, addressInfo));
+            const address = await this.wallet.getBoardingAddress();
+            event.source?.postMessage(Response.boardingAddress(message.id, address));
         }
         catch (error) {
-            console.error("Error getting address info:", error);
+            console.error("Error getting boarding address:", error);
             const errorMessage = error instanceof Error
                 ? error.message
                 : "Unknown error occurred";
@@ -231,40 +244,52 @@ export class Worker {
             return;
         }
         try {
-            const coins = await this.wallet.getCoins();
-            const onchainConfirmed = coins
-                .filter((coin) => coin.status.confirmed)
-                .reduce((sum, coin) => sum + coin.value, 0);
-            const onchainUnconfirmed = coins
-                .filter((coin) => !coin.status.confirmed)
-                .reduce((sum, coin) => sum + coin.value, 0);
-            const onchainTotal = onchainConfirmed + onchainUnconfirmed;
-            const spendableVtxos = await this.vtxoRepository.getSpendableVtxos();
-            const offchainSettledBalance = spendableVtxos.reduce((sum, vtxo) => vtxo.virtualStatus.state === "settled"
-                ? sum + vtxo.value
-                : sum, 0);
-            const offchainPendingBalance = spendableVtxos.reduce((sum, vtxo) => vtxo.virtualStatus.state === "pending"
-                ? sum + vtxo.value
-                : sum, 0);
-            const offchainSweptBalance = spendableVtxos.reduce((sum, vtxo) => vtxo.virtualStatus.state === "swept"
-                ? sum + vtxo.value
-                : sum, 0);
-            const offchainTotal = offchainSettledBalance +
-                offchainPendingBalance +
-                offchainSweptBalance;
+            const [boardingUtxos, spendableVtxos, sweptVtxos] = await Promise.all([
+                this.wallet.getBoardingUtxos(),
+                this.vtxoRepository.getSpendableVtxos(),
+                this.vtxoRepository.getSweptVtxos(),
+            ]);
+            // boarding
+            let confirmed = 0;
+            let unconfirmed = 0;
+            for (const utxo of boardingUtxos) {
+                if (utxo.status.confirmed) {
+                    confirmed += utxo.value;
+                }
+                else {
+                    unconfirmed += utxo.value;
+                }
+            }
+            // offchain
+            let settled = 0;
+            let preconfirmed = 0;
+            let recoverable = 0;
+            for (const vtxo of spendableVtxos) {
+                if (vtxo.virtualStatus.state === "settled") {
+                    settled += vtxo.value;
+                }
+                else if (vtxo.virtualStatus.state === "preconfirmed") {
+                    preconfirmed += vtxo.value;
+                }
+            }
+            for (const vtxo of sweptVtxos) {
+                if (isSpendable(vtxo)) {
+                    recoverable += vtxo.value;
+                }
+            }
+            const totalBoarding = confirmed + unconfirmed;
+            const totalOffchain = settled + preconfirmed + recoverable;
             event.source?.postMessage(Response.balance(message.id, {
-                onchain: {
-                    confirmed: onchainConfirmed,
-                    unconfirmed: onchainUnconfirmed,
-                    total: onchainTotal,
-                },
-                offchain: {
-                    swept: offchainSweptBalance,
-                    settled: offchainSettledBalance,
-                    pending: offchainPendingBalance,
-                    total: offchainTotal,
+                boarding: {
+                    confirmed,
+                    unconfirmed,
+                    total: totalBoarding,
                 },
-                total: onchainTotal + offchainTotal,
+                settled,
+                preconfirmed,
+                available: settled + preconfirmed,
+                recoverable,
+                total: totalBoarding + totalOffchain,
             }));
         }
         catch (error) {
@@ -275,30 +300,6 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, errorMessage));
         }
     }
-    async handleGetCoins(event) {
-        const message = event.data;
-        if (!Request.isGetCoins(message)) {
-            console.error("Invalid GET_COINS message format", message);
-            event.source?.postMessage(Response.error(message.id, "Invalid GET_COINS message format"));
-            return;
-        }
-        if (!this.wallet) {
-            console.error("Wallet not initialized");
-            event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
-            return;
-        }
-        try {
-            const coins = await this.wallet.getCoins();
-            event.source?.postMessage(Response.coins(message.id, coins));
-        }
-        catch (error) {
-            console.error("Error getting coins:", error);
-            const errorMessage = error instanceof Error
-                ? error.message
-                : "Unknown error occurred";
-            event.source?.postMessage(Response.error(message.id, errorMessage));
-        }
-    }
     async handleGetVtxos(event) {
         const message = event.data;
         if (!Request.isGetVtxos(message)) {
@@ -312,7 +313,18 @@ export class Worker {
             return;
         }
         try {
-            const vtxos = await this.vtxoRepository.getSpendableVtxos();
+            let vtxos = await this.vtxoRepository.getSpendableVtxos();
+            if (!message.filter?.withRecoverable) {
+                if (!this.wallet)
+                    throw new Error("Wallet not initialized");
+                // exclude subdust is we don't want recoverable
+                vtxos = vtxos.filter((v) => !isSubdust(v, this.wallet.dustAmount));
+            }
+            if (message.filter?.withRecoverable) {
+                // get also swept and spendable vtxos
+                const sweptVtxos = await this.vtxoRepository.getSweptVtxos();
+                vtxos.push(...sweptVtxos.filter(isSpendable));
+            }
             event.source?.postMessage(Response.vtxos(message.id, vtxos));
         }
         catch (error) {
@@ -360,7 +372,7 @@ export class Worker {
             return;
         }
         try {
-            const { boardingTxs, roundsToIgnore } = await this.wallet.getBoardingTxs();
+            const { boardingTxs, commitmentsToIgnore: roundsToIgnore } = await this.wallet.getBoardingTxs();
             const { spendable, spent } = await this.vtxoRepository.getAllVtxos();
             // convert VTXOs to offchain transactions
             const offchainTxs = vtxosToTxs(spendable, spent, roundsToIgnore);
@@ -394,11 +406,11 @@ export class Worker {
         }
         event.source?.postMessage(Response.walletStatus(message.id, this.wallet !== undefined));
     }
-    async handleExit(event) {
+    async handleSign(event) {
         const message = event.data;
-        if (!Request.isExit(message)) {
-            console.error("Invalid EXIT message format", message);
-            event.source?.postMessage(Response.error(message.id, "Invalid EXIT message format"));
+        if (!Request.isSign(message)) {
+            console.error("Invalid SIGN message format", message);
+            event.source?.postMessage(Response.error(message.id, "Invalid SIGN message format"));
             return;
         }
         if (!this.wallet) {
@@ -407,11 +419,12 @@ export class Worker {
             return;
         }
         try {
-            await this.wallet.exit(message.outpoints);
-            event.source?.postMessage(Response.exitSuccess(message.id));
+            const tx = Transaction.fromPSBT(base64.decode(message.tx));
+            const signedTx = await this.wallet.identity.sign(tx, message.inputIndexes);
+            event.source?.postMessage(Response.signSuccess(message.id, base64.encode(signedTx.toPSBT())));
         }
         catch (error) {
-            console.error("Error exiting:", error);
+            console.error("Error signing:", error);
             const errorMessage = error instanceof Error
                 ? error.message
                 : "Unknown error occurred";
@@ -443,18 +456,14 @@ export class Worker {
                 await this.handleGetAddress(event);
                 break;
             }
-            case "GET_ADDRESS_INFO": {
-                await this.handleGetAddressInfo(event);
+            case "GET_BOARDING_ADDRESS": {
+                await this.handleGetBoardingAddress(event);
                 break;
             }
             case "GET_BALANCE": {
                 await this.handleGetBalance(event);
                 break;
             }
-            case "GET_COINS": {
-                await this.handleGetCoins(event);
-                break;
-            }
             case "GET_VTXOS": {
                 await this.handleGetVtxos(event);
                 break;
@@ -471,14 +480,14 @@ export class Worker {
                 await this.handleGetStatus(event);
                 break;
             }
-            case "EXIT": {
-                await this.handleExit(event);
-                break;
-            }
             case "CLEAR": {
                 await this.handleClear(event);
                 break;
             }
+            case "SIGN": {
+                await this.handleSign(event);
+                break;
+            }
             default:
                 event.source?.postMessage(Response.error(message.id, "Unknown message type"));
         }