@arkade-os/sdk 0.2.3 → 0.3.0-alpha.1

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

@@ -3,93 +3,91 @@ 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");
+const indexedDB_1 = require("../../storage/indexedDB");
+const walletRepository_1 = require("../../repositories/walletRepository");
+const contractRepository_1 = require("../../repositories/contractRepository");
+const utils_1 = require("./utils");
+const isPrivateKeyIdentity = (identity) => {
+    return (identity.toHex !== undefined &&
+        typeof identity.toHex === "function" &&
+        typeof identity.toHex() === "string" &&
+        identity.toHex().length > 0);
+};
 class UnexpectedResponseError extends Error {
     constructor(response) {
         super(`Unexpected response type. Got: ${JSON.stringify(response, null, 2)}`);
         this.name = "UnexpectedResponseError";
     }
 }
-/**
- * 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) {
+    constructor(serviceWorker, identity, walletRepository, contractRepository) {
         this.serviceWorker = serviceWorker;
+        this.identity = identity;
+        this.walletRepository = walletRepository;
+        this.contractRepository = contractRepository;
     }
-    async getStatus() {
-        const message = {
-            type: "GET_STATUS",
-            id: getRandomId(),
-        };
-        const response = await this.sendMessage(message);
-        if (response_1.Response.isWalletStatus(response)) {
-            const { walletInitialized, xOnlyPublicKey } = response.status;
-            if (walletInitialized)
-                this.cachedXOnlyPublicKey = xOnlyPublicKey;
-            return response.status;
-        }
-        throw new UnexpectedResponseError(response);
-    }
-    async init(config, failIfInitialized = false) {
-        // Check if wallet is already initialized
-        const statusMessage = {
-            type: "GET_STATUS",
-            id: getRandomId(),
-        };
-        const response = await this.sendMessage(statusMessage);
-        if (response_1.Response.isWalletStatus(response) &&
-            response.status.walletInitialized) {
-            if (failIfInitialized) {
-                throw new Error("Wallet already initialized");
-            }
-            this.cachedXOnlyPublicKey = response.status.xOnlyPublicKey;
-            return;
+    static async create(options) {
+        // Default to IndexedDB for service worker context
+        const storage = options.storage || new indexedDB_1.IndexedDBStorageAdapter("wallet-db");
+        // Create repositories
+        const walletRepo = new walletRepository_1.WalletRepositoryImpl(storage);
+        const contractRepo = new contractRepository_1.ContractRepositoryImpl(storage);
+        // Extract identity and check if it can expose private key
+        const identity = isPrivateKeyIdentity(options.identity)
+            ? options.identity
+            : null;
+        if (!identity) {
+            throw new Error("ServiceWorkerWallet.create() requires a Identity that can expose its private key");
         }
-        // If not initialized, proceed with initialization
-        const message = {
+        // Extract private key for service worker initialization
+        const privateKey = identity.toHex();
+        // Create the wallet instance
+        const wallet = new ServiceWorkerWallet(options.serviceWorker, identity, walletRepo, contractRepo);
+        // Initialize the service worker with the config
+        const initMessage = {
             type: "INIT_WALLET",
             id: getRandomId(),
-            privateKey: config.privateKey,
-            arkServerUrl: config.arkServerUrl,
-            arkServerPublicKey: config.arkServerPublicKey,
+            privateKey,
+            arkServerUrl: options.arkServerUrl,
+            arkServerPublicKey: options.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();
+        // Initialize the service worker
+        await wallet.sendMessage(initMessage);
+        return wallet;
     }
-    async clear() {
-        const message = {
-            type: "CLEAR",
-            id: getRandomId(),
-        };
-        await this.sendMessage(message);
-        // clear the cached xOnlyPublicKey
-        this.cachedXOnlyPublicKey = undefined;
+    /**
+     * Simplified setup method that handles service worker registration,
+     * identity creation, and wallet initialization automatically.
+     *
+     * @example
+     * ```typescript
+     * // One-liner setup - handles everything automatically!
+     * const wallet = await ServiceWorkerWallet.setup({
+     *   serviceWorkerPath: '/service-worker.js',
+     *   arkServerUrl: 'https://mutinynet.arkade.sh'
+     * });
+     *
+     * // With custom identity
+     * const identity = SingleKey.fromHex('your_private_key_hex');
+     * const wallet = await ServiceWorkerWallet.setup({
+     *   serviceWorkerPath: '/service-worker.js',
+     *   arkServerUrl: 'https://mutinynet.arkade.sh',
+     *   identity
+     * });
+     * ```
+     */
+    static async setup(options) {
+        // Register and setup the service worker
+        const serviceWorker = await (0, utils_1.setupServiceWorker)(options.serviceWorkerPath);
+        // Use the existing create method
+        return await ServiceWorkerWallet.create({
+            arkServerPublicKey: options.arkServerPublicKey,
+            arkServerUrl: options.arkServerUrl,
+            esploraUrl: options.esploraUrl,
+            identity: options.identity,
+            serviceWorker,
+            storage: options.storage,
+        });
     }
     // send a message and wait for a response
     async sendMessage(message) {
@@ -115,6 +113,21 @@ class ServiceWorkerWallet {
             this.serviceWorker.postMessage(message);
         });
     }
+    async clear() {
+        const message = {
+            type: "CLEAR",
+            id: getRandomId(),
+        };
+        // Clear page-side storage to maintain parity with SW
+        try {
+            const address = await this.getAddress();
+            await this.walletRepository.clearVtxos(address);
+        }
+        catch (_) {
+            console.warn("Failed to clear vtxos from wallet repository");
+        }
+        await this.sendMessage(message);
+    }
     async getAddress() {
         const message = {
             type: "GET_ADDRESS",
@@ -163,37 +176,64 @@ class ServiceWorkerWallet {
             throw new Error(`Failed to get balance: ${error}`);
         }
     }
-    async getVtxos(filter) {
+    async getBoardingUtxos() {
         const message = {
-            type: "GET_VTXOS",
+            type: "GET_BOARDING_UTXOS",
             id: getRandomId(),
-            filter,
         };
         try {
             const response = await this.sendMessage(message);
-            if (response_1.Response.isVtxos(response)) {
-                return response.vtxos;
+            if (response_1.Response.isBoardingUtxos(response)) {
+                return response.boardingUtxos;
             }
             throw new UnexpectedResponseError(response);
         }
         catch (error) {
-            throw new Error(`Failed to get vtxos: ${error}`);
+            throw new Error(`Failed to get boarding UTXOs: ${error}`);
         }
     }
-    async getBoardingUtxos() {
+    async getStatus() {
         const message = {
-            type: "GET_BOARDING_UTXOS",
+            type: "GET_STATUS",
+            id: getRandomId(),
+        };
+        const response = await this.sendMessage(message);
+        if (response_1.Response.isWalletStatus(response)) {
+            return response.status;
+        }
+        throw new UnexpectedResponseError(response);
+    }
+    async getTransactionHistory() {
+        const message = {
+            type: "GET_TRANSACTION_HISTORY",
             id: getRandomId(),
         };
         try {
             const response = await this.sendMessage(message);
-            if (response_1.Response.isBoardingUtxos(response)) {
-                return response.boardingUtxos;
+            if (response_1.Response.isTransactionHistory(response)) {
+                return response.transactions;
             }
             throw new UnexpectedResponseError(response);
         }
         catch (error) {
-            throw new Error(`Failed to get boarding UTXOs: ${error}`);
+            throw new Error(`Failed to get transaction history: ${error}`);
+        }
+    }
+    async getVtxos(filter) {
+        const message = {
+            type: "GET_VTXOS",
+            id: getRandomId(),
+            filter,
+        };
+        try {
+            const response = await this.sendMessage(message);
+            if (response_1.Response.isVtxos(response)) {
+                return response.vtxos;
+            }
+            throw new UnexpectedResponseError(response);
+        }
+        catch (error) {
+            throw new Error(`Failed to get vtxos: ${error}`);
         }
     }
     async sendBitcoin(params) {
@@ -250,52 +290,6 @@ class ServiceWorkerWallet {
             throw new Error(`Settlement failed: ${error}`);
         }
     }
-    async getTransactionHistory() {
-        const message = {
-            type: "GET_TRANSACTION_HISTORY",
-            id: getRandomId(),
-        };
-        try {
-            const response = await this.sendMessage(message);
-            if (response_1.Response.isTransactionHistory(response)) {
-                return response.transactions;
-            }
-            throw new UnexpectedResponseError(response);
-        }
-        catch (error) {
-            throw new Error(`Failed to get transaction history: ${error}`);
-        }
-    }
-    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: "SIGN",
-            tx: base_1.base64.encode(tx.toPSBT()),
-            inputIndexes,
-            id: getRandomId(),
-        };
-        try {
-            const response = await this.sendMessage(message);
-            if (response_1.Response.isSignSuccess(response)) {
-                return btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(response.tx), {
-                    allowUnknown: true,
-                    allowUnknownInputs: true,
-                });
-            }
-            throw new UnexpectedResponseError(response);
-        }
-        catch (error) {
-            throw new Error(`Failed to sign: ${error}`);
-        }
-    }
 }
 exports.ServiceWorkerWallet = ServiceWorkerWallet;
 function getRandomId() {

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

@@ -8,19 +8,53 @@ const wallet_1 = require("../wallet");
 const request_1 = require("./request");
 const response_1 = require("./response");
 const ark_1 = require("../../providers/ark");
-const idb_1 = require("./db/vtxo/idb");
 const transactionHistory_1 = require("../../utils/transactionHistory");
 const indexer_1 = require("../../providers/indexer");
 const base_1 = require("@scure/base");
-const btc_signer_1 = require("@scure/btc-signer");
+const indexedDB_1 = require("../../storage/indexedDB");
+const walletRepository_1 = require("../../repositories/walletRepository");
 /**
  * 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;
+    constructor(messageCallback = () => { }) {
         this.messageCallback = messageCallback;
+        this.storage = new indexedDB_1.IndexedDBStorageAdapter("arkade-service-worker", 1);
+        this.walletRepository = new walletRepository_1.WalletRepositoryImpl(this.storage);
+    }
+    /**
+     * Get spendable vtxos for the current wallet address
+     */
+    async getSpendableVtxos() {
+        if (!this.wallet)
+            return [];
+        const address = await this.wallet.getAddress();
+        const allVtxos = await this.walletRepository.getVtxos(address);
+        return allVtxos.filter(__1.isSpendable);
+    }
+    /**
+     * Get swept vtxos for the current wallet address
+     */
+    async getSweptVtxos() {
+        if (!this.wallet)
+            return [];
+        const address = await this.wallet.getAddress();
+        const allVtxos = await this.walletRepository.getVtxos(address);
+        return allVtxos.filter((vtxo) => vtxo.virtualStatus.state === "swept" && (0, __1.isSpendable)(vtxo));
+    }
+    /**
+     * Get all vtxos categorized by type
+     */
+    async getAllVtxos() {
+        if (!this.wallet)
+            return { spendable: [], spent: [] };
+        const address = await this.wallet.getAddress();
+        const allVtxos = await this.walletRepository.getVtxos(address);
+        return {
+            spendable: allVtxos.filter(__1.isSpendable),
+            spent: allVtxos.filter((vtxo) => !(0, __1.isSpendable)(vtxo)),
+        };
     }
     async start(withServiceWorkerUpdate = true) {
         self.addEventListener("message", async (event) => {
@@ -41,7 +75,8 @@ class Worker {
         if (this.vtxoSubscription) {
             this.vtxoSubscription.abort();
         }
-        await this.vtxoRepository.close();
+        // Clear storage - this replaces vtxoRepository.close()
+        await this.storage.clear();
         this.wallet = undefined;
         this.arkProvider = undefined;
         this.indexerProvider = undefined;
@@ -60,8 +95,6 @@ class Worker {
             !this.wallet.boardingTapscript) {
             return;
         }
-        // subscribe to address updates
-        await this.vtxoRepository.open();
         const encodedOffchainTapscript = this.wallet.offchainTapscript.encode();
         const forfeit = this.wallet.offchainTapscript.forfeit();
         const exit = this.wallet.offchainTapscript.exit();
@@ -76,7 +109,9 @@ class Worker {
             intentTapLeafScript: exit,
             tapTree: encodedOffchainTapscript,
         }));
-        await this.vtxoRepository.addOrUpdate(vtxos);
+        // Get wallet address and save vtxos using unified repository
+        const address = await this.wallet.getAddress();
+        await this.walletRepository.saveVtxos(address, vtxos);
         this.processVtxoSubscription({
             script,
             vtxoScript: this.wallet.offchainTapscript,
@@ -102,7 +137,11 @@ class Worker {
                     intentTapLeafScript,
                     tapTree,
                 }));
-                await this.vtxoRepository.addOrUpdate(extendedVtxos);
+                // Get wallet address and save vtxos using unified repository
+                const address = await this.wallet.getAddress();
+                await this.walletRepository.saveVtxos(address, extendedVtxos);
+                // Notify all clients about the vtxo update
+                this.sendMessageToAllClients("VTXO_UPDATE", "");
             }
         }
         catch (error) {
@@ -110,7 +149,7 @@ class Worker {
         }
     }
     async handleClear(event) {
-        this.clear();
+        await this.clear();
         if (request_1.Request.isBase(event.data)) {
             event.source?.postMessage(response_1.Response.clearResponse(event.data.id, true));
         }
@@ -122,13 +161,22 @@ class Worker {
             event.source?.postMessage(response_1.Response.error(message.id, "Invalid INIT_WALLET message format"));
             return;
         }
+        if (!message.privateKey) {
+            const err = "Missing privateKey";
+            event.source?.postMessage(response_1.Response.error(message.id, err));
+            console.error(err);
+            return;
+        }
         try {
-            this.arkProvider = new ark_1.RestArkProvider(message.arkServerUrl);
-            this.indexerProvider = new indexer_1.RestIndexerProvider(message.arkServerUrl);
+            const { arkServerPublicKey, arkServerUrl, privateKey } = message;
+            const identity = singleKey_1.SingleKey.fromHex(privateKey);
+            this.arkProvider = new ark_1.RestArkProvider(arkServerUrl);
+            this.indexerProvider = new indexer_1.RestIndexerProvider(arkServerUrl);
             this.wallet = await wallet_1.Wallet.create({
-                identity: singleKey_1.SingleKey.fromHex(message.privateKey),
-                arkServerUrl: message.arkServerUrl,
-                arkServerPublicKey: message.arkServerPublicKey,
+                identity,
+                arkServerUrl,
+                arkServerPublicKey,
+                storage: this.storage, // Use unified storage for wallet too
             });
             event.source?.postMessage(response_1.Response.walletInitialized(message.id));
             await this.onWalletInitialized();
@@ -254,8 +302,8 @@ class Worker {
         try {
             const [boardingUtxos, spendableVtxos, sweptVtxos] = await Promise.all([
                 this.wallet.getBoardingUtxos(),
-                this.vtxoRepository.getSpendableVtxos(),
-                this.vtxoRepository.getSweptVtxos(),
+                this.getSpendableVtxos(),
+                this.getSweptVtxos(),
             ]);
             // boarding
             let confirmed = 0;
@@ -321,7 +369,7 @@ class Worker {
             return;
         }
         try {
-            let vtxos = await this.vtxoRepository.getSpendableVtxos();
+            let vtxos = await this.getSpendableVtxos();
             if (!message.filter?.withRecoverable) {
                 if (!this.wallet)
                     throw new Error("Wallet not initialized");
@@ -330,7 +378,7 @@ class Worker {
             }
             if (message.filter?.withRecoverable) {
                 // get also swept and spendable vtxos
-                const sweptVtxos = await this.vtxoRepository.getSweptVtxos();
+                const sweptVtxos = await this.getSweptVtxos();
                 vtxos.push(...sweptVtxos.filter(__1.isSpendable));
             }
             event.source?.postMessage(response_1.Response.vtxos(message.id, vtxos));
@@ -381,7 +429,7 @@ class Worker {
         }
         try {
             const { boardingTxs, commitmentsToIgnore: roundsToIgnore } = await this.wallet.getBoardingTxs();
-            const { spendable, spent } = await this.vtxoRepository.getAllVtxos();
+            const { spendable, spent } = await this.getAllVtxos();
             // convert VTXOs to offchain transactions
             const offchainTxs = (0, transactionHistory_1.vtxosToTxs)(spendable, spent, roundsToIgnore);
             const txs = [...boardingTxs, ...offchainTxs];
@@ -412,35 +460,10 @@ class Worker {
             event.source?.postMessage(response_1.Response.error(message.id, "Invalid GET_STATUS message format"));
             return;
         }
-        event.source?.postMessage(response_1.Response.walletStatus(message.id, this.wallet !== undefined, this.wallet?.identity.xOnlyPublicKey()));
-    }
-    async handleSign(event) {
-        const message = event.data;
-        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) {
-            console.error("Wallet not initialized");
-            event.source?.postMessage(response_1.Response.error(message.id, "Wallet not initialized"));
-            return;
-        }
-        try {
-            const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(message.tx), {
-                allowUnknown: true,
-                allowUnknownInputs: true,
-            });
-            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 signing:", error);
-            const errorMessage = error instanceof Error
-                ? error.message
-                : "Unknown error occurred";
-            event.source?.postMessage(response_1.Response.error(message.id, errorMessage));
-        }
+        const pubKey = this.wallet
+            ? await this.wallet.identity.xOnlyPublicKey()
+            : undefined;
+        event.source?.postMessage(response_1.Response.walletStatus(message.id, this.wallet !== undefined, pubKey));
     }
     async handleMessage(event) {
         this.messageCallback(event);
@@ -495,13 +518,21 @@ class Worker {
                 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"));
         }
     }
+    async sendMessageToAllClients(type, message) {
+        self.clients
+            .matchAll({ includeUncontrolled: true, type: "window" })
+            .then((clients) => {
+            clients.forEach((client) => {
+                client.postMessage({
+                    type,
+                    message,
+                });
+            });
+        });
+    }
 }
 exports.Worker = Worker;

package/dist/cjs/wallet/unroll.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unroll = void 0;
-const btc_signer_1 = require("@scure/btc-signer");
+const transaction_js_1 = require("@scure/btc-signer/transaction.js");
 const indexer_1 = require("../providers/indexer");
 const base_1 = require("@scure/base");
 const base_2 = require("../script/base");
-const psbt_1 = require("@scure/btc-signer/psbt");
+const psbt_js_1 = require("@scure/btc-signer/psbt.js");
 const txSizeEstimator_1 = require("../utils/txSizeEstimator");
 const wallet_1 = require("./wallet");
 var Unroll;
@@ -106,7 +106,7 @@ var Unroll;
             if (virtualTxs.txs.length === 0) {
                 throw new Error(`Tx ${nextTxToBroadcast.txid} not found`);
             }
-            const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(virtualTxs.txs[0]), {
+            const tx = transaction_js_1.Transaction.fromPSBT(base_1.base64.decode(virtualTxs.txs[0]), {
                 allowUnknownInputs: true,
             });
             // finalize the tree transaction
@@ -197,11 +197,11 @@ var Unroll;
                     amount: BigInt(vtxo.value),
                     script: base_2.VtxoScript.decode(vtxo.tapTree).pkScript,
                 },
-                sighashType: btc_signer_1.SigHash.DEFAULT,
+                sighashType: transaction_js_1.SigHash.DEFAULT,
             });
-            txWeightEstimator.addTapscriptInput(64, spendingLeaf[1].length, psbt_1.TaprootControlBlock.encode(spendingLeaf[0]).length);
+            txWeightEstimator.addTapscriptInput(64, spendingLeaf[1].length, psbt_js_1.TaprootControlBlock.encode(spendingLeaf[0]).length);
         }
-        const tx = new btc_signer_1.Transaction({ allowUnknownInputs: true, version: 2 });
+        const tx = new transaction_js_1.Transaction({ allowUnknownInputs: true, version: 2 });
         for (const input of inputs) {
             tx.addInput(input);
         }