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

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

@@ -1,92 +1,90 @@
 import { Response } from './response.js';
-import { base64, hex } from "@scure/base";
-import { SingleKey } from '../../identity/singleKey.js';
-import { TreeSignerSession } from '../../tree/signingSession.js';
-import { Transaction } from "@scure/btc-signer";
+import { hex } from "@scure/base";
+import { IndexedDBStorageAdapter } from '../../storage/indexedDB.js';
+import { WalletRepositoryImpl } from '../../repositories/walletRepository.js';
+import { ContractRepositoryImpl } from '../../repositories/contractRepository.js';
+import { setupServiceWorker } from './utils.js';
+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();
- * ```
- */
 export 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.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.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 IndexedDBStorageAdapter("wallet-db");
+        // Create repositories
+        const walletRepo = new WalletRepositoryImpl(storage);
+        const contractRepo = new 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 = hex.decode(config.privateKey);
-        // cache the identity xOnlyPublicKey
-        this.cachedXOnlyPublicKey =
-            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 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) {
@@ -112,6 +110,21 @@ export 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",
@@ -160,37 +173,64 @@ export 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.isVtxos(response)) {
-                return response.vtxos;
+            if (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.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.isBoardingUtxos(response)) {
-                return response.boardingUtxos;
+            if (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.isVtxos(response)) {
+                return response.vtxos;
+            }
+            throw new UnexpectedResponseError(response);
+        }
+        catch (error) {
+            throw new Error(`Failed to get vtxos: ${error}`);
         }
     }
     async sendBitcoin(params) {
@@ -247,52 +287,6 @@ export 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.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 TreeSignerSession.random();
-    }
-    async sign(tx, inputIndexes) {
-        const message = {
-            type: "SIGN",
-            tx: base64.encode(tx.toPSBT()),
-            inputIndexes,
-            id: getRandomId(),
-        };
-        try {
-            const response = await this.sendMessage(message);
-            if (Response.isSignSuccess(response)) {
-                return Transaction.fromPSBT(base64.decode(response.tx), {
-                    allowUnknown: true,
-                    allowUnknownInputs: true,
-                });
-            }
-            throw new UnexpectedResponseError(response);
-        }
-        catch (error) {
-            throw new Error(`Failed to sign: ${error}`);
-        }
-    }
 }
 function getRandomId() {
     const randomValue = crypto.getRandomValues(new Uint8Array(16));

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

@@ -5,19 +5,53 @@ import { Wallet } from '../wallet.js';
 import { Request } from './request.js';
 import { Response } from './response.js';
 import { RestArkProvider } from '../../providers/ark.js';
-import { IndexedDBVtxoRepository } from './db/vtxo/idb.js';
 import { vtxosToTxs } from '../../utils/transactionHistory.js';
 import { RestIndexerProvider } from '../../providers/indexer.js';
-import { base64, hex } from "@scure/base";
-import { Transaction } from "@scure/btc-signer";
+import { hex } from "@scure/base";
+import { IndexedDBStorageAdapter } from '../../storage/indexedDB.js';
+import { WalletRepositoryImpl, } from '../../repositories/walletRepository.js';
 /**
  * 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;
+    constructor(messageCallback = () => { }) {
         this.messageCallback = messageCallback;
+        this.storage = new IndexedDBStorageAdapter("arkade-service-worker", 1);
+        this.walletRepository = new 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(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" && 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(isSpendable),
+            spent: allVtxos.filter((vtxo) => !isSpendable(vtxo)),
+        };
     }
     async start(withServiceWorkerUpdate = true) {
         self.addEventListener("message", async (event) => {
@@ -38,7 +72,8 @@ export 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;
@@ -57,8 +92,6 @@ export 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();
@@ -73,7 +106,9 @@ export 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,
@@ -99,7 +134,11 @@ export 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) {
@@ -107,7 +146,7 @@ export class Worker {
         }
     }
     async handleClear(event) {
-        this.clear();
+        await this.clear();
         if (Request.isBase(event.data)) {
             event.source?.postMessage(Response.clearResponse(event.data.id, true));
         }
@@ -119,13 +158,22 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid INIT_WALLET message format"));
             return;
         }
+        if (!message.privateKey) {
+            const err = "Missing privateKey";
+            event.source?.postMessage(Response.error(message.id, err));
+            console.error(err);
+            return;
+        }
         try {
-            this.arkProvider = new RestArkProvider(message.arkServerUrl);
-            this.indexerProvider = new RestIndexerProvider(message.arkServerUrl);
+            const { arkServerPublicKey, arkServerUrl, privateKey } = message;
+            const identity = SingleKey.fromHex(privateKey);
+            this.arkProvider = new RestArkProvider(arkServerUrl);
+            this.indexerProvider = new RestIndexerProvider(arkServerUrl);
             this.wallet = await Wallet.create({
-                identity: 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.walletInitialized(message.id));
             await this.onWalletInitialized();
@@ -251,8 +299,8 @@ export 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;
@@ -318,7 +366,7 @@ export 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");
@@ -327,7 +375,7 @@ export 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(isSpendable));
             }
             event.source?.postMessage(Response.vtxos(message.id, vtxos));
@@ -378,7 +426,7 @@ export 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 = vtxosToTxs(spendable, spent, roundsToIgnore);
             const txs = [...boardingTxs, ...offchainTxs];
@@ -409,35 +457,10 @@ export class Worker {
             event.source?.postMessage(Response.error(message.id, "Invalid GET_STATUS message format"));
             return;
         }
-        event.source?.postMessage(Response.walletStatus(message.id, this.wallet !== undefined, this.wallet?.identity.xOnlyPublicKey()));
-    }
-    async handleSign(event) {
-        const message = event.data;
-        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) {
-            console.error("Wallet not initialized");
-            event.source?.postMessage(Response.error(message.id, "Wallet not initialized"));
-            return;
-        }
-        try {
-            const tx = Transaction.fromPSBT(base64.decode(message.tx), {
-                allowUnknown: true,
-                allowUnknownInputs: true,
-            });
-            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 signing:", error);
-            const errorMessage = error instanceof Error
-                ? error.message
-                : "Unknown error occurred";
-            event.source?.postMessage(Response.error(message.id, errorMessage));
-        }
+        const pubKey = this.wallet
+            ? await this.wallet.identity.xOnlyPublicKey()
+            : undefined;
+        event.source?.postMessage(Response.walletStatus(message.id, this.wallet !== undefined, pubKey));
     }
     async handleMessage(event) {
         this.messageCallback(event);
@@ -492,12 +515,20 @@ export class Worker {
                 await this.handleClear(event);
                 break;
             }
-            case "SIGN": {
-                await this.handleSign(event);
-                break;
-            }
             default:
                 event.source?.postMessage(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,
+                });
+            });
+        });
+    }
 }

package/dist/esm/wallet/unroll.js

@@ -1,8 +1,8 @@
-import { SigHash, Transaction } from "@scure/btc-signer";
+import { SigHash, Transaction } from "@scure/btc-signer/transaction.js";
 import { ChainTxType } from '../providers/indexer.js';
 import { base64, hex } from "@scure/base";
 import { VtxoScript } from '../script/base.js';
-import { TaprootControlBlock, } from "@scure/btc-signer/psbt";
+import { TaprootControlBlock, } from "@scure/btc-signer/psbt.js";
 import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
 import { Wallet } from './wallet.js';
 export var Unroll;

package/dist/esm/wallet/wallet.js

@@ -1,8 +1,8 @@
 import { base64, hex } from "@scure/base";
 import * as bip68 from "bip68";
-import { Address, OutScript, tapLeafHash } from "@scure/btc-signer/payment";
-import { SigHash, Transaction } from "@scure/btc-signer";
-import { TaprootControlBlock, } from "@scure/btc-signer/psbt";
+import { Address, OutScript, tapLeafHash } from "@scure/btc-signer/payment.js";
+import { SigHash, Transaction } from "@scure/btc-signer/transaction.js";
+import { TaprootControlBlock, } from "@scure/btc-signer/psbt.js";
 import { vtxosToTxs } from '../utils/transactionHistory.js';
 import { ArkAddress } from '../script/address.js';
 import { DefaultVtxo } from '../script/default.js';
@@ -12,7 +12,7 @@ import { SettlementEventType, RestArkProvider, } from '../providers/ark.js';
 import { buildForfeitTx } from '../forfeit.js';
 import { validateConnectorsTxGraph, validateVtxoTxGraph, } from '../tree/validation.js';
 import { isRecoverable, isSpendable, isSubdust, TxType, } from './index.js';
-import { sha256, sha256x2 } from "@scure/btc-signer/utils";
+import { sha256, sha256x2 } from "@scure/btc-signer/utils.js";
 import { VtxoScript } from '../script/base.js';
 import { CSVMultisigTapscript } from '../script/tapscript.js';
 import { buildOffchainTx } from '../utils/arkTransaction.js';
@@ -20,6 +20,9 @@ import { ArkNote } from '../arknote/index.js';
 import { BIP322 } from '../bip322/index.js';
 import { RestIndexerProvider } from '../providers/indexer.js';
 import { TxTree } from '../tree/txTree.js';
+import { InMemoryStorageAdapter } from '../storage/inMemory.js';
+import { WalletRepositoryImpl, } from '../repositories/walletRepository.js';
+import { ContractRepositoryImpl, } from '../repositories/contractRepository.js';
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
  * The wallet does not store any data locally and relies on Ark and onchain
@@ -46,7 +49,7 @@ import { TxTree } from '../tree/txTree.js';
  * ```
  */
 export 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;
@@ -59,9 +62,11 @@ export 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");
         }
@@ -101,7 +106,11 @@ export class Wallet {
         // server is expecting funds to be sent to this address
         const forfeitAddress = Address(network).decode(info.forfeitAddress);
         const forfeitOutputScript = 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 InMemoryStorageAdapter();
+        const walletRepository = new WalletRepositoryImpl(storage);
+        const contractRepository = new 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);
@@ -157,16 +166,24 @@ export 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 = [hex.encode(this.offchainTapscript.pkScript)];

package/dist/types/adapters/asyncStorage.d.ts

@@ -0,0 +1,2 @@
+export { AsyncStorageAdapter } from "../storage/asyncStorage";
+export type { StorageAdapter } from "../storage";

package/dist/types/adapters/fileSystem.d.ts

@@ -0,0 +1,2 @@
+export { FileSystemStorageAdapter } from "../storage/fileSystem";
+export type { StorageAdapter } from "../storage";

package/dist/types/adapters/indexedDB.d.ts

@@ -0,0 +1,2 @@
+export { IndexedDBStorageAdapter } from "../storage/indexedDB";
+export type { StorageAdapter } from "../storage";

package/dist/types/adapters/localStorage.d.ts

@@ -0,0 +1,2 @@
+export { LocalStorageAdapter } from "../storage/localStorage";
+export type { StorageAdapter } from "../storage";