@arkade-os/sdk 0.1.4 → 0.2.0

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Response = void 0;
+/**
+ * Response is the namespace that contains the response types for the service worker.
+ */
 var Response;
 (function (Response) {
     Response.walletInitialized = (id) => ({
@@ -43,28 +46,28 @@ var Response;
         return response.type === "ADDRESS" && response.success === true;
     }
     Response.isAddress = isAddress;
-    function addresses(id, addresses) {
+    function isBoardingAddress(response) {
+        return (response.type === "BOARDING_ADDRESS" && response.success === true);
+    }
+    Response.isBoardingAddress = isBoardingAddress;
+    function address(id, address) {
         return {
             type: "ADDRESS",
             success: true,
-            addresses,
+            address,
             id,
         };
     }
-    Response.addresses = addresses;
-    function isAddressInfo(response) {
-        return response.type === "ADDRESS_INFO" && response.success === true;
-    }
-    Response.isAddressInfo = isAddressInfo;
-    function addressInfo(id, addressInfo) {
+    Response.address = address;
+    function boardingAddress(id, address) {
         return {
-            type: "ADDRESS_INFO",
+            type: "BOARDING_ADDRESS",
             success: true,
-            addressInfo,
+            address,
             id,
         };
     }
-    Response.addressInfo = addressInfo;
+    Response.boardingAddress = boardingAddress;
     function isBalance(response) {
         return response.type === "BALANCE" && response.success === true;
     }
@@ -78,19 +81,6 @@ var Response;
         };
     }
     Response.balance = balance;
-    function isCoins(response) {
-        return response.type === "COINS" && response.success === true;
-    }
-    Response.isCoins = isCoins;
-    function coins(id, coins) {
-        return {
-            type: "COINS",
-            success: true,
-            coins,
-            id,
-        };
-    }
-    Response.coins = coins;
     function isVtxos(response) {
         return response.type === "VTXOS" && response.success === true;
     }
@@ -184,12 +174,17 @@ var Response;
         };
     }
     Response.clearResponse = clearResponse;
-    function exitSuccess(id) {
+    function signSuccess(id, tx) {
         return {
-            type: "EXIT_SUCCESS",
+            type: "SIGN_SUCCESS",
             success: true,
+            tx,
             id,
         };
     }
-    Response.exitSuccess = exitSuccess;
+    Response.signSuccess = signSuccess;
+    function isSignSuccess(response) {
+        return response.type === "SIGN_SUCCESS" && response.success === true;
+    }
+    Response.isSignSuccess = isSignSuccess;
 })(Response || (exports.Response = Response = {}));

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

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupServiceWorker = setupServiceWorker;
+/**
+ * setupServiceWorker sets up the service worker.
+ * @param path - the path to the service worker script
+ * @example
+ * ```typescript
+ * const serviceWorker = await setupServiceWorker("/service-worker.js");
+ * ```
+ */
 async function setupServiceWorker(path) {
     // check if service workers are supported
     if (!("serviceWorker" in navigator)) {

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

@@ -3,13 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceWorkerWallet = void 0;
 const response_1 = require("./response");
 const base_1 = require("@scure/base");
+const singleKey_1 = require("../../identity/singleKey");
+const signingSession_1 = require("../../tree/signingSession");
+const btc_signer_1 = require("@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();
+ * ```
+ */
 class ServiceWorkerWallet {
     constructor(serviceWorker) {
         this.serviceWorker = serviceWorker;
@@ -44,11 +69,14 @@ 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 = base_1.hex.decode(config.privateKey);
+        // cache the identity xOnlyPublicKey
+        this.cachedXOnlyPublicKey =
+            singleKey_1.SingleKey.fromPrivateKey(privKeyBytes).xOnlyPublicKey();
     }
     async clear() {
         const message = {
@@ -56,6 +84,8 @@ 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) {
@@ -89,7 +119,7 @@ class ServiceWorkerWallet {
         try {
             const response = await this.sendMessage(message);
             if (response_1.Response.isAddress(response)) {
-                return response.addresses;
+                return response.address;
             }
             throw new UnexpectedResponseError(response);
         }
@@ -97,20 +127,20 @@ 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_1.Response.isAddressInfo(response)) {
-                return response.addressInfo;
+            if (response_1.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() {
@@ -129,26 +159,11 @@ 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_1.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);
@@ -177,11 +192,10 @@ 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 {
@@ -248,21 +262,31 @@ 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 signingSession_1.TreeSignerSession.random();
+    }
+    async sign(tx, inputIndexes) {
         const message = {
-            type: "EXIT",
-            outpoints,
+            type: "SIGN",
+            tx: base_1.base64.encode(tx.toPSBT()),
+            inputIndexes,
             id: getRandomId(),
         };
         try {
             const response = await this.sendMessage(message);
-            if (response.type === "EXIT_SUCCESS") {
-                return;
+            if (response_1.Response.isSignSuccess(response)) {
+                return btc_signer_1.Transaction.fromPSBT(base_1.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/cjs/wallet/serviceWorker/worker.js

@@ -2,16 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Worker = void 0;
 /// <reference lib="webworker" />
-const inMemoryKey_1 = require("../../identity/inMemoryKey");
+const singleKey_1 = require("../../identity/singleKey");
+const __1 = require("..");
 const wallet_1 = require("../wallet");
 const request_1 = require("./request");
 const response_1 = require("./response");
 const ark_1 = require("../../providers/ark");
-const default_1 = require("../../script/default");
 const idb_1 = require("./db/vtxo/idb");
 const transactionHistory_1 = require("../../utils/transactionHistory");
-// Worker is a class letting to interact with ServiceWorkerWallet from the client
-// it aims to be run in a service worker context
+const indexer_1 = require("../../providers/indexer");
+const base_1 = require("@scure/base");
+const btc_signer_1 = require("@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
+ */
 class Worker {
     constructor(vtxoRepository = new idb_1.IndexedDBVtxoRepository(), messageCallback = () => { }) {
         this.vtxoRepository = vtxoRepository;
@@ -39,41 +44,48 @@ 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 = base_1.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 = default_1.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) {
@@ -81,8 +93,9 @@ class Worker {
                 }
                 const extendedVtxos = vtxos.map((vtxo) => ({
                     ...vtxo,
-                    tapLeafScript,
-                    scripts: addressScripts,
+                    forfeitTapLeafScript,
+                    intentTapLeafScript,
+                    tapTree,
                 }));
                 await this.vtxoRepository.addOrUpdate(extendedVtxos);
             }
@@ -106,9 +119,9 @@ class Worker {
         }
         try {
             this.arkProvider = new ark_1.RestArkProvider(message.arkServerUrl);
+            this.indexerProvider = new indexer_1.RestIndexerProvider(message.arkServerUrl);
             this.wallet = await wallet_1.Wallet.create({
-                network: message.network,
-                identity: inMemoryKey_1.InMemoryKey.fromHex(message.privateKey),
+                identity: singleKey_1.SingleKey.fromHex(message.privateKey),
                 arkServerUrl: message.arkServerUrl,
                 arkServerPublicKey: message.arkServerPublicKey,
             });
@@ -162,7 +175,7 @@ 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_1.Response.sendBitcoinSuccess(message.id, txid));
         }
         catch (error) {
@@ -186,8 +199,8 @@ class Worker {
             return;
         }
         try {
-            const addresses = await this.wallet.getAddress();
-            event.source?.postMessage(response_1.Response.addresses(message.id, addresses));
+            const address = await this.wallet.getAddress();
+            event.source?.postMessage(response_1.Response.address(message.id, address));
         }
         catch (error) {
             console.error("Error getting address:", error);
@@ -197,11 +210,11 @@ class Worker {
             event.source?.postMessage(response_1.Response.error(message.id, errorMessage));
         }
     }
-    async handleGetAddressInfo(event) {
+    async handleGetBoardingAddress(event) {
         const message = event.data;
-        if (!request_1.Request.isGetAddressInfo(message)) {
-            console.error("Invalid GET_ADDRESS_INFO message format", message);
-            event.source?.postMessage(response_1.Response.error(message.id, "Invalid GET_ADDRESS_INFO message format"));
+        if (!request_1.Request.isGetBoardingAddress(message)) {
+            console.error("Invalid GET_BOARDING_ADDRESS message format", message);
+            event.source?.postMessage(response_1.Response.error(message.id, "Invalid GET_BOARDING_ADDRESS message format"));
             return;
         }
         if (!this.wallet) {
@@ -210,11 +223,11 @@ class Worker {
             return;
         }
         try {
-            const addressInfo = await this.wallet.getAddressInfo();
-            event.source?.postMessage(response_1.Response.addressInfo(message.id, addressInfo));
+            const address = await this.wallet.getBoardingAddress();
+            event.source?.postMessage(response_1.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";
@@ -234,40 +247,52 @@ 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 ((0, __1.isSpendable)(vtxo)) {
+                    recoverable += vtxo.value;
+                }
+            }
+            const totalBoarding = confirmed + unconfirmed;
+            const totalOffchain = settled + preconfirmed + recoverable;
             event.source?.postMessage(response_1.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) {
@@ -278,30 +303,6 @@ class Worker {
             event.source?.postMessage(response_1.Response.error(message.id, errorMessage));
         }
     }
-    async handleGetCoins(event) {
-        const message = event.data;
-        if (!request_1.Request.isGetCoins(message)) {
-            console.error("Invalid GET_COINS message format", message);
-            event.source?.postMessage(response_1.Response.error(message.id, "Invalid GET_COINS message format"));
-            return;
-        }
-        if (!this.wallet) {
-            console.error("Wallet not initialized");
-            event.source?.postMessage(response_1.Response.error(message.id, "Wallet not initialized"));
-            return;
-        }
-        try {
-            const coins = await this.wallet.getCoins();
-            event.source?.postMessage(response_1.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_1.Response.error(message.id, errorMessage));
-        }
-    }
     async handleGetVtxos(event) {
         const message = event.data;
         if (!request_1.Request.isGetVtxos(message)) {
@@ -315,7 +316,18 @@ 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) => !(0, __1.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(__1.isSpendable));
+            }
             event.source?.postMessage(response_1.Response.vtxos(message.id, vtxos));
         }
         catch (error) {
@@ -363,7 +375,7 @@ 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 = (0, transactionHistory_1.vtxosToTxs)(spendable, spent, roundsToIgnore);
@@ -397,11 +409,11 @@ class Worker {
         }
         event.source?.postMessage(response_1.Response.walletStatus(message.id, this.wallet !== undefined));
     }
-    async handleExit(event) {
+    async handleSign(event) {
         const message = event.data;
-        if (!request_1.Request.isExit(message)) {
-            console.error("Invalid EXIT message format", message);
-            event.source?.postMessage(response_1.Response.error(message.id, "Invalid EXIT message format"));
+        if (!request_1.Request.isSign(message)) {
+            console.error("Invalid SIGN message format", message);
+            event.source?.postMessage(response_1.Response.error(message.id, "Invalid SIGN message format"));
             return;
         }
         if (!this.wallet) {
@@ -410,11 +422,12 @@ class Worker {
             return;
         }
         try {
-            await this.wallet.exit(message.outpoints);
-            event.source?.postMessage(response_1.Response.exitSuccess(message.id));
+            const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(message.tx));
+            const signedTx = await this.wallet.identity.sign(tx, message.inputIndexes);
+            event.source?.postMessage(response_1.Response.signSuccess(message.id, base_1.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";
@@ -446,18 +459,14 @@ 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;
@@ -474,14 +483,14 @@ 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_1.Response.error(message.id, "Unknown message type"));
         }