@arkade-os/sdk 0.2.2 → 0.3.0-alpha.0

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,12 +75,18 @@ 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;
         this.vtxoSubscription = undefined;
     }
+    async reload() {
+        if (this.vtxoSubscription)
+            this.vtxoSubscription.abort();
+        await this.onWalletInitialized();
+    }
     async onWalletInitialized() {
         if (!this.wallet ||
             !this.arkProvider ||
@@ -55,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();
@@ -71,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,
@@ -97,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) {
@@ -105,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));
         }
@@ -117,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();
@@ -249,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;
@@ -316,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");
@@ -325,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));
@@ -376,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];
@@ -407,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);
@@ -490,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/wallet.js

@@ -57,6 +57,9 @@ const arknote_1 = require("../arknote");
 const bip322_1 = require("../bip322");
 const indexer_1 = require("../providers/indexer");
 const txTree_1 = require("../tree/txTree");
+const inMemory_1 = require("../storage/inMemory");
+const walletRepository_1 = require("../repositories/walletRepository");
+const contractRepository_1 = require("../repositories/contractRepository");
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
  * The wallet does not store any data locally and relies on Ark and onchain
@@ -83,7 +86,7 @@ const txTree_1 = require("../tree/txTree");
  * ```
  */
 class Wallet {
-    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, dustAmount) {
+    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, dustAmount, walletRepository, contractRepository) {
         this.identity = identity;
         this.network = network;
         this.networkName = networkName;
@@ -96,9 +99,11 @@ class Wallet {
         this.serverUnrollScript = serverUnrollScript;
         this.forfeitOutputScript = forfeitOutputScript;
         this.dustAmount = dustAmount;
+        this.walletRepository = walletRepository;
+        this.contractRepository = contractRepository;
     }
     static async create(config) {
-        const pubkey = config.identity.xOnlyPublicKey();
+        const pubkey = await config.identity.xOnlyPublicKey();
         if (!pubkey) {
             throw new Error("Invalid configured public key");
         }
@@ -138,7 +143,11 @@ class Wallet {
         // server is expecting funds to be sent to this address
         const forfeitAddress = (0, payment_1.Address)(network).decode(info.forfeitAddress);
         const forfeitOutputScript = payment_1.OutScript.encode(forfeitAddress);
-        return new Wallet(config.identity, network, info.network, onchainProvider, arkProvider, indexerProvider, serverPubKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, info.dust);
+        // Set up storage and repositories
+        const storage = config.storage || new inMemory_1.InMemoryStorageAdapter();
+        const walletRepository = new walletRepository_1.WalletRepositoryImpl(storage);
+        const contractRepository = new contractRepository_1.ContractRepositoryImpl(storage);
+        return new Wallet(config.identity, network, info.network, onchainProvider, arkProvider, indexerProvider, serverPubKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, info.dust, walletRepository, contractRepository);
     }
     get arkAddress() {
         return this.offchainTapscript.address(this.network.hrp, this.arkServerPublicKey);
@@ -194,16 +203,24 @@ class Wallet {
         };
     }
     async getVtxos(filter) {
+        const address = await this.getAddress();
+        // Try to get from cache first
+        const cachedVtxos = await this.walletRepository.getVtxos(address);
+        // For now, always fetch fresh data from provider and update cache
+        // In future, we can add cache invalidation logic based on timestamps
         const spendableVtxos = await this.getVirtualCoins(filter);
         const encodedOffchainTapscript = this.offchainTapscript.encode();
         const forfeit = this.offchainTapscript.forfeit();
         const exit = this.offchainTapscript.exit();
-        return spendableVtxos.map((vtxo) => ({
+        const extendedVtxos = spendableVtxos.map((vtxo) => ({
             ...vtxo,
             forfeitTapLeafScript: forfeit,
             intentTapLeafScript: exit,
             tapTree: encodedOffchainTapscript,
         }));
+        // Update cache with fresh data
+        await this.walletRepository.saveVtxos(address, extendedVtxos);
+        return extendedVtxos;
     }
     async getVirtualCoins(filter = { withRecoverable: true, withUnrolled: false }) {
         const scripts = [base_1.hex.encode(this.offchainTapscript.pkScript)];

package/dist/esm/adapters/asyncStorage.js

@@ -0,0 +1 @@
+export { AsyncStorageAdapter } from '../storage/asyncStorage.js';

package/dist/esm/adapters/fileSystem.js

@@ -0,0 +1 @@
+export { FileSystemStorageAdapter } from '../storage/fileSystem.js';

package/dist/esm/adapters/indexedDB.js

@@ -0,0 +1 @@
+export { IndexedDBStorageAdapter } from '../storage/indexedDB.js';

package/dist/esm/adapters/localStorage.js

@@ -0,0 +1 @@
+export { LocalStorageAdapter } from '../storage/localStorage.js';

package/dist/esm/bip322/index.js

@@ -1,6 +1,6 @@
 import { OP, Transaction, Script, SigHash } from "@scure/btc-signer";
 import { ErrMissingData, ErrMissingInputs, ErrMissingWitnessUtxo, } from './errors.js';
-import { schnorr } from "@noble/curves/secp256k1";
+import { schnorr } from "@noble/curves/secp256k1.js";
 import { base64 } from "@scure/base";
 /**
  * BIP-322 signature implementation for Bitcoin message signing.

package/dist/esm/identity/index.js

@@ -1 +1 @@
-export {};
+export * from './singleKey.js';