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

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

@@ -1,9 +1,13 @@
-import { IWallet, WalletBalance, SendBitcoinParams, SettleParams, ArkTransaction, WalletConfig, ExtendedCoin, ExtendedVirtualCoin, GetVtxosFilter } from "..";
+import { IWallet, WalletBalance, SendBitcoinParams, SettleParams, ArkTransaction, ExtendedCoin, ExtendedVirtualCoin, GetVtxosFilter } from "..";
 import { Response } from "./response";
 import { SettlementEvent } from "../../providers/ark";
 import { Identity } from "../../identity";
-import { SignerSession } from "../../tree/signingSession";
-import { Transaction } from "@scure/btc-signer";
+import { StorageAdapter } from "../../storage";
+import { WalletRepository } from "../../repositories/walletRepository";
+import { ContractRepository } from "../../repositories/contractRepository";
+export type PrivateKeyIdentity = Identity & {
+    toHex(): string;
+};
 /**
  * Service Worker-based wallet implementation for browser environments.
  *
@@ -14,12 +18,21 @@ import { Transaction } from "@scure/btc-signer";
  *
  * @example
  * ```typescript
- * // Create and initialize the service worker wallet
+ * // SIMPLE: Recommended approach
+ * const identity = SingleKey.fromHex('your_private_key_hex');
+ * const wallet = await ServiceWorkerWallet.setup({
+ *   serviceWorkerPath: '/service-worker.js',
+ *   arkServerUrl: 'https://mutinynet.arkade.sh',
+ *   identity
+ * });
+ *
+ * // ADVANCED: Manual setup with service worker control
  * 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'
+ * const identity = SingleKey.fromHex('your_private_key_hex');
+ * const wallet = await ServiceWorkerWallet.create({
+ *   serviceWorker,
+ *   identity,
+ *   arkServerUrl: 'https://mutinynet.arkade.sh'
  * });
  *
  * // Use like any other wallet
@@ -27,25 +40,58 @@ import { Transaction } from "@scure/btc-signer";
  * const balance = await wallet.getBalance();
  * ```
  */
-export declare class ServiceWorkerWallet implements IWallet, Identity {
+interface ServiceWorkerWalletOptions {
+    arkServerPublicKey?: string;
+    arkServerUrl: string;
+    esploraUrl?: string;
+    identity: PrivateKeyIdentity;
+    storage?: StorageAdapter;
+}
+export type ServiceWorkerWalletCreateOptions = ServiceWorkerWalletOptions & {
+    serviceWorker: ServiceWorker;
+};
+export type ServiceWorkerWalletSetupOptions = ServiceWorkerWalletOptions & {
+    serviceWorkerPath: string;
+};
+export declare class ServiceWorkerWallet implements IWallet {
     readonly serviceWorker: ServiceWorker;
-    private cachedXOnlyPublicKey;
-    constructor(serviceWorker: ServiceWorker);
-    getStatus(): Promise<Response.WalletStatus["status"]>;
-    init(config: Omit<WalletConfig, "identity"> & {
-        privateKey: string;
-    }, failIfInitialized?: boolean): Promise<void>;
-    clear(): Promise<void>;
+    readonly walletRepository: WalletRepository;
+    readonly contractRepository: ContractRepository;
+    readonly identity: Identity;
+    private constructor();
+    static create(options: ServiceWorkerWalletCreateOptions): Promise<ServiceWorkerWallet>;
+    /**
+     * 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 setup(options: ServiceWorkerWalletSetupOptions): Promise<ServiceWorkerWallet>;
     private sendMessage;
+    clear(): Promise<void>;
     getAddress(): Promise<string>;
     getBoardingAddress(): Promise<string>;
     getBalance(): Promise<WalletBalance>;
-    getVtxos(filter?: GetVtxosFilter): Promise<ExtendedVirtualCoin[]>;
     getBoardingUtxos(): Promise<ExtendedCoin[]>;
+    getStatus(): Promise<Response.WalletStatus["status"]>;
+    getTransactionHistory(): Promise<ArkTransaction[]>;
+    getVtxos(filter?: GetVtxosFilter): Promise<ExtendedVirtualCoin[]>;
     sendBitcoin(params: SendBitcoinParams): Promise<string>;
     settle(params?: SettleParams, callback?: (event: SettlementEvent) => void): Promise<string>;
-    getTransactionHistory(): Promise<ArkTransaction[]>;
-    xOnlyPublicKey(): Uint8Array;
-    signerSession(): SignerSession;
-    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
 }
+export {};

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

@@ -1,16 +1,28 @@
-import { VtxoRepository } from "./db/vtxo";
 /**
  * Worker is a class letting to interact with ServiceWorkerWallet from the client
  * it aims to be run in a service worker context
  */
 export declare class Worker {
-    private readonly vtxoRepository;
     private readonly messageCallback;
     private wallet;
     private arkProvider;
     private indexerProvider;
     private vtxoSubscription;
-    constructor(vtxoRepository?: VtxoRepository, messageCallback?: (message: ExtendableMessageEvent) => void);
+    private walletRepository;
+    private storage;
+    constructor(messageCallback?: (message: ExtendableMessageEvent) => void);
+    /**
+     * Get spendable vtxos for the current wallet address
+     */
+    private getSpendableVtxos;
+    /**
+     * Get swept vtxos for the current wallet address
+     */
+    private getSweptVtxos;
+    /**
+     * Get all vtxos categorized by type
+     */
+    private getAllVtxos;
     start(withServiceWorkerUpdate?: boolean): Promise<void>;
     clear(): Promise<void>;
     reload(): Promise<void>;
@@ -27,6 +39,6 @@ export declare class Worker {
     private handleGetBoardingUtxos;
     private handleGetTransactionHistory;
     private handleGetStatus;
-    private handleSign;
     private handleMessage;
+    private sendMessageToAllClients;
 }

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

@@ -8,6 +8,8 @@ import { ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, GetVtxosFilter
 import { Bytes } from "@scure/btc-signer/utils";
 import { CSVMultisigTapscript } from "../script/tapscript";
 import { IndexerProvider } from "../providers/indexer";
+import { WalletRepository } from "../repositories/walletRepository";
+import { ContractRepository } from "../repositories/contractRepository";
 export type IncomingFunds = {
     type: "utxo";
     coins: Coin[];
@@ -54,6 +56,8 @@ export declare class Wallet implements IWallet {
     readonly forfeitOutputScript: Bytes;
     readonly dustAmount: bigint;
     static MIN_FEE_RATE: number;
+    readonly walletRepository: WalletRepository;
+    readonly contractRepository: ContractRepository;
     private constructor();
     static create(config: WalletConfig): Promise<Wallet>;
     get arkAddress(): ArkAddress;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.2.3",
+  "version": "0.3.0-alpha.0",
   "description": "Bitcoin wallet SDK with Taproot and Ark integration",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -13,6 +13,30 @@
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js",
       "default": "./dist/esm/index.js"
+    },
+    "./adapters/localStorage": {
+      "types": "./dist/types/adapters/localStorage.d.ts",
+      "import": "./dist/esm/adapters/localStorage.js",
+      "require": "./dist/cjs/adapters/localStorage.js",
+      "default": "./dist/esm/adapters/localStorage.js"
+    },
+    "./adapters/fileSystem": {
+      "types": "./dist/types/adapters/fileSystem.d.ts",
+      "import": "./dist/esm/adapters/fileSystem.js",
+      "require": "./dist/cjs/adapters/fileSystem.js",
+      "default": "./dist/esm/adapters/fileSystem.js"
+    },
+    "./adapters/indexedDB": {
+      "types": "./dist/types/adapters/indexedDB.d.ts",
+      "import": "./dist/esm/adapters/indexedDB.js",
+      "require": "./dist/cjs/adapters/indexedDB.js",
+      "default": "./dist/esm/adapters/indexedDB.js"
+    },
+    "./adapters/asyncStorage": {
+      "types": "./dist/types/adapters/asyncStorage.d.ts",
+      "import": "./dist/esm/adapters/asyncStorage.js",
+      "require": "./dist/cjs/adapters/asyncStorage.js",
+      "default": "./dist/esm/adapters/asyncStorage.js"
     }
   },
   "files": [
@@ -23,24 +47,24 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@noble/curves": "1.9.1",
-    "@noble/hashes": "1.8.0",
-    "@noble/secp256k1": "2.2.3",
-    "@scure/base": "1.2.6",
+    "@noble/curves": "2.0.0",
+    "@noble/hashes": "2.0.0",
+    "@noble/secp256k1": "3.0.0",
+    "@scure/base": "2.0.0",
     "@scure/btc-signer": "1.8.1",
     "bip68": "1.0.4"
   },
   "devDependencies": {
-    "rimraf": "^5.0.0",
-    "@types/node": "22.10.2",
-    "@vitest/coverage-v8": "2.1.9",
-    "esbuild": "^0.20.1",
-    "glob": "11.0.1",
+    "@types/node": "24.3.1",
+    "@vitest/coverage-v8": "3.2.4",
+    "esbuild": "^0.25.9",
+    "glob": "11.0.3",
     "husky": "9.1.7",
-    "prettier": "3.4.2",
-    "typedoc": "^0.27.1",
-    "typescript": "5.7.2",
-    "vitest": "2.1.9"
+    "prettier": "3.6.2",
+    "rimraf": "^6.0.1",
+    "typedoc": "^0.28.12",
+    "typescript": "5.9.2",
+    "vitest": "3.2.4"
   },
   "keywords": [
     "bitcoin",

package/dist/cjs/wallet/serviceWorker/db/vtxo/idb.js

@@ -1,185 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexedDBVtxoRepository = void 0;
-class IndexedDBVtxoRepository {
-    constructor() {
-        this.db = null;
-    }
-    static delete() {
-        return new Promise((resolve, reject) => {
-            try {
-                const request = indexedDB.deleteDatabase(IndexedDBVtxoRepository.DB_NAME);
-                request.onblocked = () => {
-                    // If blocked, wait a bit and try again
-                    setTimeout(() => {
-                        const retryRequest = indexedDB.deleteDatabase(IndexedDBVtxoRepository.DB_NAME);
-                        retryRequest.onsuccess = () => resolve();
-                        retryRequest.onerror = () => reject(retryRequest.error ||
-                            new Error("Failed to delete database"));
-                    }, 100);
-                };
-                request.onsuccess = () => {
-                    resolve();
-                };
-                request.onerror = () => {
-                    reject(request.error || new Error("Failed to delete database"));
-                };
-            }
-            catch (error) {
-                reject(error instanceof Error
-                    ? error
-                    : new Error("Failed to delete database"));
-            }
-        });
-    }
-    async close() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-        }
-    }
-    async open() {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open(IndexedDBVtxoRepository.DB_NAME, IndexedDBVtxoRepository.DB_VERSION);
-            request.onerror = () => {
-                reject(request.error);
-            };
-            request.onsuccess = () => {
-                this.db = request.result;
-                resolve();
-            };
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains(IndexedDBVtxoRepository.STORE_NAME)) {
-                    const store = db.createObjectStore(IndexedDBVtxoRepository.STORE_NAME, {
-                        keyPath: ["txid", "vout"],
-                    });
-                    store.createIndex("state", "virtualStatus.state", {
-                        unique: false,
-                    });
-                    store.createIndex("spentBy", "spentBy", {
-                        unique: false,
-                    });
-                }
-            };
-        });
-    }
-    async addOrUpdate(vtxos) {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readwrite");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const requests = vtxos.map((vtxo) => {
-                return new Promise((resolveRequest, rejectRequest) => {
-                    const request = store.put(vtxo);
-                    request.onsuccess = () => resolveRequest();
-                    request.onerror = () => rejectRequest(request.error);
-                });
-            });
-            Promise.all(requests)
-                .then(() => resolve())
-                .catch(reject);
-        });
-    }
-    async deleteAll() {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readwrite");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const request = store.clear();
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
-        });
-    }
-    async getSpendableVtxos() {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const spentByIndex = store.index("spentBy");
-            // Get vtxos where spentBy is empty string
-            const request = spentByIndex.getAll(IDBKeyRange.only(""));
-            request.onsuccess = () => {
-                resolve(request.result);
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-    async getSweptVtxos() {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const stateIndex = store.index("state");
-            // Get vtxos where state is "swept"
-            const request = stateIndex.getAll(IDBKeyRange.only("swept"));
-            request.onsuccess = () => {
-                resolve(request.result);
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-    async getSpentVtxos() {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const spentByIndex = store.index("spentBy");
-            // Get vtxos where spentBy is not empty string
-            const request = spentByIndex.getAll(IDBKeyRange.lowerBound("", true));
-            request.onsuccess = () => {
-                resolve(request.result);
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-    async getAllVtxos() {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const spentByIndex = store.index("spentBy");
-            // Get vtxos where spentBy is empty string
-            const spendableRequest = spentByIndex.getAll(IDBKeyRange.only(""));
-            // Get all vtxos where spentBy is populated
-            const spentRequest = spentByIndex.getAll(IDBKeyRange.lowerBound("", true));
-            Promise.all([
-                new Promise((resolveSpendable, rejectSpendable) => {
-                    spendableRequest.onsuccess = () => {
-                        resolveSpendable(spendableRequest.result);
-                    };
-                    spendableRequest.onerror = () => rejectSpendable(spendableRequest.error);
-                }),
-                new Promise((resolveSpent, rejectSpent) => {
-                    spentRequest.onsuccess = () => {
-                        resolveSpent(spentRequest.result);
-                    };
-                    spentRequest.onerror = () => rejectSpent(spentRequest.error);
-                }),
-            ])
-                .then(([spendableVtxos, spentVtxos]) => {
-                resolve({
-                    spendable: spendableVtxos,
-                    spent: spentVtxos,
-                });
-            })
-                .catch(reject);
-        });
-    }
-}
-exports.IndexedDBVtxoRepository = IndexedDBVtxoRepository;
-IndexedDBVtxoRepository.DB_NAME = "wallet-db";
-IndexedDBVtxoRepository.STORE_NAME = "vtxos";
-IndexedDBVtxoRepository.DB_VERSION = 1;

package/dist/esm/wallet/serviceWorker/db/vtxo/idb.js

@@ -1,181 +0,0 @@
-export class IndexedDBVtxoRepository {
-    constructor() {
-        this.db = null;
-    }
-    static delete() {
-        return new Promise((resolve, reject) => {
-            try {
-                const request = indexedDB.deleteDatabase(IndexedDBVtxoRepository.DB_NAME);
-                request.onblocked = () => {
-                    // If blocked, wait a bit and try again
-                    setTimeout(() => {
-                        const retryRequest = indexedDB.deleteDatabase(IndexedDBVtxoRepository.DB_NAME);
-                        retryRequest.onsuccess = () => resolve();
-                        retryRequest.onerror = () => reject(retryRequest.error ||
-                            new Error("Failed to delete database"));
-                    }, 100);
-                };
-                request.onsuccess = () => {
-                    resolve();
-                };
-                request.onerror = () => {
-                    reject(request.error || new Error("Failed to delete database"));
-                };
-            }
-            catch (error) {
-                reject(error instanceof Error
-                    ? error
-                    : new Error("Failed to delete database"));
-            }
-        });
-    }
-    async close() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-        }
-    }
-    async open() {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open(IndexedDBVtxoRepository.DB_NAME, IndexedDBVtxoRepository.DB_VERSION);
-            request.onerror = () => {
-                reject(request.error);
-            };
-            request.onsuccess = () => {
-                this.db = request.result;
-                resolve();
-            };
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains(IndexedDBVtxoRepository.STORE_NAME)) {
-                    const store = db.createObjectStore(IndexedDBVtxoRepository.STORE_NAME, {
-                        keyPath: ["txid", "vout"],
-                    });
-                    store.createIndex("state", "virtualStatus.state", {
-                        unique: false,
-                    });
-                    store.createIndex("spentBy", "spentBy", {
-                        unique: false,
-                    });
-                }
-            };
-        });
-    }
-    async addOrUpdate(vtxos) {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readwrite");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const requests = vtxos.map((vtxo) => {
-                return new Promise((resolveRequest, rejectRequest) => {
-                    const request = store.put(vtxo);
-                    request.onsuccess = () => resolveRequest();
-                    request.onerror = () => rejectRequest(request.error);
-                });
-            });
-            Promise.all(requests)
-                .then(() => resolve())
-                .catch(reject);
-        });
-    }
-    async deleteAll() {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readwrite");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const request = store.clear();
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
-        });
-    }
-    async getSpendableVtxos() {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const spentByIndex = store.index("spentBy");
-            // Get vtxos where spentBy is empty string
-            const request = spentByIndex.getAll(IDBKeyRange.only(""));
-            request.onsuccess = () => {
-                resolve(request.result);
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-    async getSweptVtxos() {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const stateIndex = store.index("state");
-            // Get vtxos where state is "swept"
-            const request = stateIndex.getAll(IDBKeyRange.only("swept"));
-            request.onsuccess = () => {
-                resolve(request.result);
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-    async getSpentVtxos() {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const spentByIndex = store.index("spentBy");
-            // Get vtxos where spentBy is not empty string
-            const request = spentByIndex.getAll(IDBKeyRange.lowerBound("", true));
-            request.onsuccess = () => {
-                resolve(request.result);
-            };
-            request.onerror = () => reject(request.error);
-        });
-    }
-    async getAllVtxos() {
-        if (!this.db) {
-            throw new Error("Database not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
-            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
-            const spentByIndex = store.index("spentBy");
-            // Get vtxos where spentBy is empty string
-            const spendableRequest = spentByIndex.getAll(IDBKeyRange.only(""));
-            // Get all vtxos where spentBy is populated
-            const spentRequest = spentByIndex.getAll(IDBKeyRange.lowerBound("", true));
-            Promise.all([
-                new Promise((resolveSpendable, rejectSpendable) => {
-                    spendableRequest.onsuccess = () => {
-                        resolveSpendable(spendableRequest.result);
-                    };
-                    spendableRequest.onerror = () => rejectSpendable(spendableRequest.error);
-                }),
-                new Promise((resolveSpent, rejectSpent) => {
-                    spentRequest.onsuccess = () => {
-                        resolveSpent(spentRequest.result);
-                    };
-                    spentRequest.onerror = () => rejectSpent(spentRequest.error);
-                }),
-            ])
-                .then(([spendableVtxos, spentVtxos]) => {
-                resolve({
-                    spendable: spendableVtxos,
-                    spent: spentVtxos,
-                });
-            })
-                .catch(reject);
-        });
-    }
-}
-IndexedDBVtxoRepository.DB_NAME = "wallet-db";
-IndexedDBVtxoRepository.STORE_NAME = "vtxos";
-IndexedDBVtxoRepository.DB_VERSION = 1;

package/dist/types/wallet/serviceWorker/db/vtxo/idb.d.ts

@@ -1,20 +0,0 @@
-import { VtxoRepository } from ".";
-import { ExtendedVirtualCoin } from "../../..";
-export declare class IndexedDBVtxoRepository implements VtxoRepository {
-    static readonly DB_NAME = "wallet-db";
-    static readonly STORE_NAME = "vtxos";
-    static readonly DB_VERSION = 1;
-    static delete(): Promise<void>;
-    private db;
-    close(): Promise<void>;
-    open(): Promise<void>;
-    addOrUpdate(vtxos: ExtendedVirtualCoin[]): Promise<void>;
-    deleteAll(): Promise<void>;
-    getSpendableVtxos(): Promise<ExtendedVirtualCoin[]>;
-    getSweptVtxos(): Promise<ExtendedVirtualCoin[]>;
-    getSpentVtxos(): Promise<ExtendedVirtualCoin[]>;
-    getAllVtxos(): Promise<{
-        spendable: ExtendedVirtualCoin[];
-        spent: ExtendedVirtualCoin[];
-    }>;
-}

package/dist/types/wallet/serviceWorker/db/vtxo/index.d.ts

@@ -1,14 +0,0 @@
-import { ExtendedVirtualCoin } from "../../../..";
-export interface VtxoRepository {
-    addOrUpdate(vtxos: ExtendedVirtualCoin[]): Promise<void>;
-    deleteAll(): Promise<void>;
-    getSpendableVtxos(): Promise<ExtendedVirtualCoin[]>;
-    getSweptVtxos(): Promise<ExtendedVirtualCoin[]>;
-    getSpentVtxos(): Promise<ExtendedVirtualCoin[]>;
-    getAllVtxos(): Promise<{
-        spendable: ExtendedVirtualCoin[];
-        spent: ExtendedVirtualCoin[];
-    }>;
-    close(): Promise<void>;
-    open(): Promise<void>;
-}