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

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/wallet.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";

package/dist/types/identity/index.d.ts

@@ -2,6 +2,8 @@ import { Transaction } from "@scure/btc-signer";
 import { SignerSession } from "../tree/signingSession";
 export interface Identity {
     sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
-    xOnlyPublicKey(): Uint8Array;
+    xOnlyPublicKey(): Promise<Uint8Array>;
     signerSession(): SignerSession;
+    signMessage(message: string): Promise<Uint8Array>;
 }
+export * from "./singleKey";

package/dist/types/identity/singleKey.d.ts

@@ -12,6 +12,9 @@ import { SignerSession } from "../tree/signingSession";
  * // Create from raw bytes
  * const key = SingleKey.fromPrivateKey(privateKeyBytes);
  *
+ * // Create random key
+ * const randomKey = SingleKey.fromRandomBytes();
+ *
  * // Sign a transaction
  * const signedTx = await key.sign(transaction);
  * ```
@@ -21,7 +24,15 @@ export declare class SingleKey implements Identity {
     private constructor();
     static fromPrivateKey(privateKey: Uint8Array): SingleKey;
     static fromHex(privateKeyHex: string): SingleKey;
+    static fromRandomBytes(): SingleKey;
+    /**
+     * Export the private key as a hex string.
+     *
+     * @returns The private key as a hex string
+     */
+    toHex(): string;
     sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
-    xOnlyPublicKey(): Uint8Array;
+    xOnlyPublicKey(): Promise<Uint8Array>;
     signerSession(): SignerSession;
+    signMessage(message: string): Promise<Uint8Array>;
 }

package/dist/types/index.d.ts

@@ -23,13 +23,13 @@ import { buildOffchainTx, ArkTxInput, OffchainTx } from "./utils/arkTransaction"
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry } from "./utils/unknownFields";
 import { BIP322 } from "./bip322";
 import { ArkNote } from "./arknote";
-import { IndexedDBVtxoRepository } from "./wallet/serviceWorker/db/vtxo/idb";
-import { VtxoRepository } from "./wallet/serviceWorker/db/vtxo";
 import { networks, Network, NetworkName } from "./networks";
 import { RestIndexerProvider, IndexerProvider, IndexerTxType, ChainTxType, PageResponse, Batch, ChainTx, CommitmentTx, TxHistoryRecord, VtxoChain, Tx, Vtxo, PaginationOptions, SubscriptionResponse } from "./providers/indexer";
 import { Nonces } from "./musig2/nonces";
 import { PartialSig } from "./musig2/sign";
 import { AnchorBumper, P2A } from "./utils/anchor";
 import { Unroll } from "./wallet/unroll";
-export { Wallet, SingleKey, OnchainWallet, Ramps, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, Worker, ServiceWorkerWallet, Request, Response, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, waitForIncomingFunds, ArkNote, networks, IndexedDBVtxoRepository, BIP322, TxTree, P2A, Unroll, Transaction, };
-export type { Identity, IWallet, WalletConfig, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, VtxoRepository, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, IndexerProvider, PageResponse, Batch, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, ArkInfo, Intent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesAggregatedEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, MarketHour, PaginationOptions, SubscriptionResponse, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, };
+import { WalletRepositoryImpl } from "./repositories/walletRepository";
+import { ContractRepositoryImpl } from "./repositories/contractRepository";
+export { Wallet, SingleKey, OnchainWallet, Ramps, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, Worker, ServiceWorkerWallet, Request, Response, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, waitForIncomingFunds, ArkNote, networks, WalletRepositoryImpl, ContractRepositoryImpl, BIP322, TxTree, P2A, Unroll, Transaction, };
+export type { Identity, IWallet, WalletConfig, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, IndexerProvider, PageResponse, Batch, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, ArkInfo, Intent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesAggregatedEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, MarketHour, PaginationOptions, SubscriptionResponse, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, };

package/dist/types/repositories/contractRepository.d.ts

@@ -0,0 +1,20 @@
+import { StorageAdapter } from "../storage";
+export interface ContractRepository {
+    getContractData<T>(contractId: string, key: string): Promise<T | null>;
+    setContractData<T>(contractId: string, key: string, data: T): Promise<void>;
+    deleteContractData(contractId: string, key: string): Promise<void>;
+    getContractCollection<T>(contractType: string): Promise<ReadonlyArray<T>>;
+    saveToContractCollection<T, K extends keyof T>(contractType: string, item: T, idField: K): Promise<void>;
+    removeFromContractCollection<T, K extends keyof T>(contractType: string, id: T[K], idField: K): Promise<void>;
+}
+export declare class ContractRepositoryImpl implements ContractRepository {
+    private storage;
+    private cache;
+    constructor(storage: StorageAdapter);
+    getContractData<T>(contractId: string, key: string): Promise<T | null>;
+    setContractData<T>(contractId: string, key: string, data: T): Promise<void>;
+    deleteContractData(contractId: string, key: string): Promise<void>;
+    getContractCollection<T>(contractType: string): Promise<ReadonlyArray<T>>;
+    saveToContractCollection<T, K extends keyof T>(contractType: string, item: T, idField: K): Promise<void>;
+    removeFromContractCollection<T, K extends keyof T>(contractType: string, id: T[K], idField: K): Promise<void>;
+}

package/dist/types/repositories/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./walletRepository";
+export * from "./contractRepository";

package/dist/types/repositories/walletRepository.d.ts

@@ -0,0 +1,38 @@
+import { StorageAdapter } from "../storage";
+import { ExtendedVirtualCoin } from "../wallet";
+export interface WalletState {
+    lastSyncTime?: number;
+    settings?: Record<string, any>;
+}
+export interface Transaction {
+    id: string;
+    timestamp: number;
+    amount: number;
+    type: "send" | "receive";
+    status: "pending" | "confirmed" | "failed";
+}
+export interface WalletRepository {
+    getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
+    saveVtxo(address: string, vtxo: ExtendedVirtualCoin): Promise<void>;
+    saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
+    removeVtxo(address: string, vtxoId: string): Promise<void>;
+    clearVtxos(address: string): Promise<void>;
+    getTransactionHistory(address: string): Promise<Transaction[]>;
+    saveTransaction(address: string, tx: Transaction): Promise<void>;
+    getWalletState(): Promise<WalletState | null>;
+    saveWalletState(state: WalletState): Promise<void>;
+}
+export declare class WalletRepositoryImpl implements WalletRepository {
+    private storage;
+    private cache;
+    constructor(storage: StorageAdapter);
+    getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
+    saveVtxo(address: string, vtxo: ExtendedVirtualCoin): Promise<void>;
+    saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
+    removeVtxo(address: string, vtxoId: string): Promise<void>;
+    clearVtxos(address: string): Promise<void>;
+    getTransactionHistory(address: string): Promise<Transaction[]>;
+    saveTransaction(address: string, tx: Transaction): Promise<void>;
+    getWalletState(): Promise<WalletState | null>;
+    saveWalletState(state: WalletState): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import type { StorageAdapter } from "./index";
+export declare class AsyncStorageAdapter implements StorageAdapter {
+    private AsyncStorage;
+    constructor();
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+import type { StorageAdapter } from "./index";
+export declare class FileSystemStorageAdapter implements StorageAdapter {
+    private readonly basePath;
+    constructor(dirPath: string);
+    private validateAndGetFilePath;
+    private ensureDirectory;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/storage/inMemory.d.ts

@@ -0,0 +1,8 @@
+import type { StorageAdapter } from "./index";
+export declare class InMemoryStorageAdapter implements StorageAdapter {
+    private store;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/storage/index.d.ts

@@ -0,0 +1,6 @@
+export interface StorageAdapter {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,12 @@
+import type { StorageAdapter } from "./index";
+export declare class IndexedDBStorageAdapter implements StorageAdapter {
+    private dbName;
+    private version;
+    private db;
+    constructor(dbName: string, version?: number);
+    private getDB;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import type { StorageAdapter } from "./index";
+export declare class LocalStorageAdapter implements StorageAdapter {
+    private getSafeLocalStorage;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/wallet/index.d.ts

@@ -3,6 +3,7 @@ import { Identity } from "../identity";
 import { RelativeTimelock } from "../script/tapscript";
 import { EncodedVtxoScript, TapLeafScript } from "../script/base";
 import { Bytes } from "@scure/btc-signer/utils";
+import { StorageAdapter } from "../storage";
 /**
  * Configuration options for wallet initialization.
  *
@@ -18,6 +19,7 @@ export interface WalletConfig {
     arkServerPublicKey?: string;
     boardingTimelock?: RelativeTimelock;
     exitTimelock?: RelativeTimelock;
+    storage?: StorageAdapter;
 }
 export interface WalletBalance {
     boarding: {
@@ -113,6 +115,7 @@ export type GetVtxosFilter = {
  * operations, and transaction management including sending, settling, and unrolling.
  */
 export interface IWallet {
+    identity: Identity;
     getAddress(): Promise<string>;
     getBoardingAddress(): Promise<string>;
     getBalance(): Promise<WalletBalance>;

package/dist/types/wallet/onchain.d.ts

@@ -14,7 +14,7 @@ import { AnchorBumper } from "../utils/anchor";
  *
  * @example
  * ```typescript
- * const wallet = new OnchainWallet(identity, 'mainnet');
+ * const wallet = await OnchainWallet.create(identity, 'mainnet');
  * const balance = await wallet.getBalance();
  * const txid = await wallet.send({
  *   address: 'bc1...',
@@ -29,7 +29,8 @@ export declare class OnchainWallet implements AnchorBumper {
     readonly onchainP2TR: P2TR;
     readonly provider: OnchainProvider;
     readonly network: Network;
-    constructor(identity: Identity, network: NetworkName, provider?: OnchainProvider);
+    private constructor();
+    static create(identity: Identity, networkName: NetworkName, provider?: OnchainProvider): Promise<OnchainWallet>;
     get address(): string;
     getCoins(): Promise<Coin[]>;
     getBalance(): Promise<number>;

package/dist/types/wallet/serviceWorker/request.d.ts

@@ -3,7 +3,7 @@ import { SettleParams, SendBitcoinParams, GetVtxosFilter } from "..";
  * Request is the namespace that contains the request types for the service worker.
  */
 export declare namespace Request {
-    type Type = "INIT_WALLET" | "SETTLE" | "GET_ADDRESS" | "GET_BOARDING_ADDRESS" | "GET_BALANCE" | "GET_VTXOS" | "GET_VIRTUAL_COINS" | "GET_BOARDING_UTXOS" | "SEND_BITCOIN" | "GET_TRANSACTION_HISTORY" | "GET_STATUS" | "CLEAR" | "SIGN";
+    type Type = "INIT_WALLET" | "SETTLE" | "GET_ADDRESS" | "GET_BOARDING_ADDRESS" | "GET_BALANCE" | "GET_VTXOS" | "GET_VIRTUAL_COINS" | "GET_BOARDING_UTXOS" | "SEND_BITCOIN" | "GET_TRANSACTION_HISTORY" | "GET_STATUS" | "CLEAR";
     interface Base {
         type: Type;
         id: string;
@@ -62,10 +62,4 @@ export declare namespace Request {
     interface Clear extends Base {
         type: "CLEAR";
     }
-    interface Sign extends Base {
-        type: "SIGN";
-        tx: string;
-        inputIndexes?: number[];
-    }
-    function isSign(message: Base): message is Sign;
 }

package/dist/types/wallet/serviceWorker/response.d.ts

@@ -4,7 +4,7 @@ import { SettlementEvent } from "../../providers/ark";
  * Response is the namespace that contains the response types for the service worker.
  */
 export declare namespace Response {
-    type Type = "WALLET_INITIALIZED" | "SETTLE_EVENT" | "SETTLE_SUCCESS" | "ADDRESS" | "BOARDING_ADDRESS" | "BALANCE" | "VTXOS" | "VIRTUAL_COINS" | "BOARDING_UTXOS" | "SEND_BITCOIN_SUCCESS" | "TRANSACTION_HISTORY" | "WALLET_STATUS" | "ERROR" | "CLEAR_RESPONSE" | "SIGN_SUCCESS";
+    type Type = "WALLET_INITIALIZED" | "SETTLE_EVENT" | "SETTLE_SUCCESS" | "ADDRESS" | "BOARDING_ADDRESS" | "BALANCE" | "VTXOS" | "VIRTUAL_COINS" | "BOARDING_UTXOS" | "SEND_BITCOIN_SUCCESS" | "TRANSACTION_HISTORY" | "WALLET_STATUS" | "ERROR" | "CLEAR_RESPONSE";
     interface Base {
         type: Type;
         success: boolean;
@@ -101,11 +101,4 @@ export declare namespace Response {
     }
     function isClearResponse(response: Base): response is ClearResponse;
     function clearResponse(id: string, success: boolean): ClearResponse;
-    interface SignSuccess extends Base {
-        type: "SIGN_SUCCESS";
-        success: true;
-        tx: string;
-    }
-    function signSuccess(id: string, tx: string): SignSuccess;
-    function isSignSuccess(response: Base): response is SignSuccess;
 }