@arkade-os/sdk 0.3.13 → 0.4.0-next.1

package/dist/esm/repositories/contractRepository.js

@@ -1,101 +1 @@
-const getContractStorageKey = (id, key) => `contract:${id}:${key}`;
-const getCollectionStorageKey = (type) => `collection:${type}`;
-export class ContractRepositoryImpl {
-    constructor(storage) {
-        this.storage = storage;
-    }
-    async getContractData(contractId, key) {
-        const stored = await this.storage.getItem(getContractStorageKey(contractId, key));
-        if (!stored)
-            return null;
-        try {
-            const data = JSON.parse(stored);
-            return data;
-        }
-        catch (error) {
-            console.error(`Failed to parse contract data for ${contractId}:${key}:`, error);
-            return null;
-        }
-    }
-    async setContractData(contractId, key, data) {
-        try {
-            await this.storage.setItem(getContractStorageKey(contractId, key), JSON.stringify(data));
-        }
-        catch (error) {
-            console.error(`Failed to persist contract data for ${contractId}:${key}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async deleteContractData(contractId, key) {
-        try {
-            await this.storage.removeItem(getContractStorageKey(contractId, key));
-        }
-        catch (error) {
-            console.error(`Failed to remove contract data for ${contractId}:${key}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async getContractCollection(contractType) {
-        const stored = await this.storage.getItem(getCollectionStorageKey(contractType));
-        if (!stored)
-            return [];
-        try {
-            const collection = JSON.parse(stored);
-            return collection;
-        }
-        catch (error) {
-            console.error(`Failed to parse contract collection ${contractType}:`, error);
-            return [];
-        }
-    }
-    async saveToContractCollection(contractType, item, idField) {
-        const collection = await this.getContractCollection(contractType);
-        // Validate that the item has the required id field
-        const itemId = item[idField];
-        if (itemId === undefined || itemId === null) {
-            throw new Error(`Item is missing required field '${String(idField)}'`);
-        }
-        // Find existing item index without mutating the original collection
-        const existingIndex = collection.findIndex((i) => i[idField] === itemId);
-        // Build new collection without mutating the cached one
-        let newCollection;
-        if (existingIndex !== -1) {
-            // Replace existing item
-            newCollection = [
-                ...collection.slice(0, existingIndex),
-                item,
-                ...collection.slice(existingIndex + 1),
-            ];
-        }
-        else {
-            // Add new item
-            newCollection = [...collection, item];
-        }
-        try {
-            await this.storage.setItem(getCollectionStorageKey(contractType), JSON.stringify(newCollection));
-        }
-        catch (error) {
-            console.error(`Failed to persist contract collection ${contractType}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async removeFromContractCollection(contractType, id, idField) {
-        // Validate input parameters
-        if (id === undefined || id === null) {
-            throw new Error(`Invalid id provided for removal: ${String(id)}`);
-        }
-        const collection = await this.getContractCollection(contractType);
-        // Build new collection without the specified item
-        const filtered = collection.filter((item) => item[idField] !== id);
-        try {
-            await this.storage.setItem(getCollectionStorageKey(contractType), JSON.stringify(filtered));
-        }
-        catch (error) {
-            console.error(`Failed to persist contract collection removal for ${contractType}:`, error);
-            throw error; // Rethrow to notify caller of failure
-        }
-    }
-    async clearContractData() {
-        await this.storage.clear();
-    }
-}
+export {};

package/dist/esm/repositories/inMemory/contractRepository.js

@@ -0,0 +1,51 @@
+/**
+ * In-memory implementation of ContractRepository.
+ * Data is ephemeral and scoped to the instance.
+ */
+export class InMemoryContractRepository {
+    constructor() {
+        this.version = 1;
+        this.contractData = new Map();
+        this.collections = new Map();
+        this.contractsByScript = new Map();
+    }
+    async clear() {
+        this.contractData.clear();
+        this.collections.clear();
+        this.contractsByScript.clear();
+    }
+    // Contract entity management methods
+    async getContracts(filter) {
+        const contracts = this.contractsByScript.values();
+        if (!filter) {
+            return [...contracts];
+        }
+        const matches = (value, criterion) => {
+            if (criterion === undefined) {
+                return true;
+            }
+            return Array.isArray(criterion)
+                ? criterion.includes(value)
+                : value === criterion;
+        };
+        const results = [];
+        for (const contract of contracts) {
+            if (matches(contract.script, filter.script) &&
+                matches(contract.state, filter.state) &&
+                matches(contract.type, filter.type)) {
+                results.push(contract);
+            }
+        }
+        return results;
+    }
+    async saveContract(contract) {
+        this.contractsByScript.set(contract.script, contract);
+    }
+    async deleteContract(script) {
+        this.contractsByScript.delete(script);
+    }
+    async [Symbol.asyncDispose]() {
+        // nothing to dispose, data is ephemeral and scoped to the instance
+        return;
+    }
+}

package/dist/esm/repositories/inMemory/walletRepository.js

@@ -0,0 +1,76 @@
+/**
+ * In-memory implementation of WalletRepository.
+ * Data is ephemeral and scoped to the instance.
+ */
+export class InMemoryWalletRepository {
+    constructor() {
+        this.version = 1;
+        this.vtxosByAddress = new Map();
+        this.utxosByAddress = new Map();
+        this.txsByAddress = new Map();
+        this.walletState = null;
+    }
+    async getVtxos(address) {
+        return this.vtxosByAddress.get(address) ?? [];
+    }
+    async saveVtxos(address, vtxos) {
+        const existing = this.vtxosByAddress.get(address) ?? [];
+        const next = mergeByKey(existing, vtxos, (item) => `${item.txid}:${item.vout}`);
+        this.vtxosByAddress.set(address, next);
+    }
+    async deleteVtxos(address) {
+        this.vtxosByAddress.delete(address);
+    }
+    async getUtxos(address) {
+        return this.utxosByAddress.get(address) ?? [];
+    }
+    async saveUtxos(address, utxos) {
+        const existing = this.utxosByAddress.get(address) ?? [];
+        const next = mergeByKey(existing, utxos, (item) => `${item.txid}:${item.vout}`);
+        this.utxosByAddress.set(address, next);
+    }
+    async deleteUtxos(address) {
+        this.utxosByAddress.delete(address);
+    }
+    async getTransactionHistory(address) {
+        return this.txsByAddress.get(address) ?? [];
+    }
+    async saveTransactions(address, txs) {
+        const existing = this.txsByAddress.get(address) ?? [];
+        const next = mergeByKey(existing, txs, serializeTxKey);
+        this.txsByAddress.set(address, next);
+    }
+    async deleteTransactions(address) {
+        this.txsByAddress.delete(address);
+    }
+    async getWalletState() {
+        return this.walletState;
+    }
+    async saveWalletState(state) {
+        this.walletState = state;
+    }
+    async clear() {
+        this.vtxosByAddress.clear();
+        this.utxosByAddress.clear();
+        this.txsByAddress.clear();
+        this.walletState = null;
+    }
+    async [Symbol.asyncDispose]() {
+        // nothing to dispose, data is ephemeral and scoped to the instance
+        return;
+    }
+}
+function serializeTxKey(tx) {
+    const key = tx.key;
+    return `${key.boardingTxid}:${key.commitmentTxid}:${key.arkTxid}`;
+}
+function mergeByKey(existing, incoming, toKey) {
+    const next = new Map();
+    existing.forEach((item) => {
+        next.set(toKey(item), item);
+    });
+    incoming.forEach((item) => {
+        next.set(toKey(item), item);
+    });
+    return Array.from(next.values());
+}

package/dist/esm/repositories/index.js

@@ -1,2 +1,10 @@
 export * from './walletRepository.js';
 export * from './contractRepository.js';
+export * from './inMemory/walletRepository.js';
+export * from './inMemory/contractRepository.js';
+export * from './indexedDB/contractRepository.js';
+export * from './indexedDB/walletRepository.js';
+export { MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, } from './migrations/fromStorageAdapter.js';
+// Deprecated
+export { WalletRepositoryImpl } from './migrations/walletRepositoryImpl.js';
+export { ContractRepositoryImpl } from './migrations/contractRepositoryImpl.js';

package/dist/esm/repositories/indexedDB/contractRepository.js

@@ -0,0 +1,183 @@
+import { DB_VERSION, STORE_CONTRACTS } from './db.js';
+import { closeDatabase, openDatabase } from './manager.js';
+import { initDatabase } from './schema.js';
+import { DEFAULT_DB_NAME } from '../../worker/browser/utils.js';
+/**
+ * IndexedDB-based implementation of ContractRepository.
+ *
+ * Data is stored as JSON strings in key/value stores.
+ */
+export class IndexedDBContractRepository {
+    constructor(dbName = DEFAULT_DB_NAME) {
+        this.dbName = dbName;
+        this.version = 1;
+        this.db = null;
+    }
+    async clear() {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_CONTRACTS], "readwrite");
+                const contractDataStore = transaction.objectStore(STORE_CONTRACTS);
+                const contractsStore = transaction.objectStore(STORE_CONTRACTS);
+                const contractDataRequest = contractDataStore.clear();
+                const contractsRequest = contractsStore.clear();
+                let completed = 0;
+                const checkComplete = () => {
+                    completed++;
+                    if (completed === 2) {
+                        resolve();
+                    }
+                };
+                contractDataRequest.onsuccess = checkComplete;
+                contractsRequest.onsuccess = checkComplete;
+                contractDataRequest.onerror = () => reject(contractDataRequest.error);
+                contractsRequest.onerror = () => reject(contractsRequest.error);
+            });
+        }
+        catch (error) {
+            console.error("Failed to clear contract data:", error);
+            throw error;
+        }
+    }
+    async getContracts(filter) {
+        try {
+            const db = await this.getDB();
+            const store = db
+                .transaction([STORE_CONTRACTS], "readonly")
+                .objectStore(STORE_CONTRACTS);
+            if (!filter || Object.keys(filter).length === 0) {
+                return new Promise((resolve, reject) => {
+                    const request = store.getAll();
+                    request.onerror = () => reject(request.error);
+                    request.onsuccess = () => resolve(request.result ?? []);
+                });
+            }
+            const normalizedFilter = normalizeFilter(filter);
+            // first by script, primary key
+            if (normalizedFilter.has("script")) {
+                const scripts = normalizedFilter.get("script");
+                const contracts = await Promise.all(scripts.map((script) => new Promise((resolve, reject) => {
+                    const req = store.get(script);
+                    req.onerror = () => reject(req.error);
+                    req.onsuccess = () => resolve(req.result);
+                })));
+                return this.applyContractFilter(contracts, normalizedFilter);
+            }
+            // by state, still an index
+            if (normalizedFilter.has("state")) {
+                const contracts = await this.getContractsByIndexValues(store, "state", normalizedFilter.get("state"));
+                return this.applyContractFilter(contracts, normalizedFilter);
+            }
+            // by type, still an index
+            if (normalizedFilter.has("type")) {
+                const contracts = await this.getContractsByIndexValues(store, "type", normalizedFilter.get("type"));
+                return this.applyContractFilter(contracts, normalizedFilter);
+            }
+            // any other filtering happens in-memory
+            const allContracts = await new Promise((resolve, reject) => {
+                const request = store.getAll();
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve(request.result ?? []);
+            });
+            return this.applyContractFilter(allContracts, normalizedFilter);
+        }
+        catch (error) {
+            console.error("Failed to get contracts:", error);
+            return [];
+        }
+    }
+    async saveContract(contract) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_CONTRACTS], "readwrite");
+                const store = transaction.objectStore(STORE_CONTRACTS);
+                const request = store.put(contract);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve();
+            });
+        }
+        catch (error) {
+            console.error("Failed to save contract:", error);
+            throw error;
+        }
+    }
+    async deleteContract(script) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_CONTRACTS], "readwrite");
+                const store = transaction.objectStore(STORE_CONTRACTS);
+                const getRequest = store.get(script);
+                getRequest.onerror = () => reject(getRequest.error);
+                getRequest.onsuccess = () => {
+                    const request = store.delete(script);
+                    request.onerror = () => reject(request.error);
+                    request.onsuccess = () => resolve();
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to delete contract ${script}:`, error);
+            throw error;
+        }
+    }
+    getContractsByIndexValues(store, indexName, values) {
+        if (values.length === 0)
+            return Promise.resolve([]);
+        const index = store.index(indexName);
+        const requests = values.map((value) => new Promise((resolve, reject) => {
+            const request = index.getAll(value);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result ?? []);
+        }));
+        return Promise.all(requests).then((results) => results.flatMap((result) => result));
+    }
+    applyContractFilter(
+    // can filter directly the result of a query
+    contracts, filter) {
+        return contracts.filter((contract) => {
+            if (contract === undefined)
+                return false;
+            if (filter.has("script") &&
+                !filter.get("script")?.includes(contract.script))
+                return false;
+            if (filter.has("state") &&
+                !filter.get("state")?.includes(contract.state))
+                return false;
+            if (filter.has("type") &&
+                !filter.get("type")?.includes(contract.type))
+                return false;
+            return true;
+        });
+    }
+    async getDB() {
+        if (this.db)
+            return this.db;
+        this.db = await openDatabase(this.dbName, DB_VERSION, initDatabase);
+        return this.db;
+    }
+    async [Symbol.asyncDispose]() {
+        if (!this.db)
+            return;
+        await closeDatabase(this.dbName);
+        this.db = null;
+    }
+}
+const FILTER_FIELDS = ["script", "state", "type"];
+// Transform all filter fields into an array of values
+function normalizeFilter(filter) {
+    const res = new Map();
+    FILTER_FIELDS.forEach((current) => {
+        if (!filter?.[current])
+            return;
+        if (Array.isArray(filter[current])) {
+            res.set(current, filter[current]);
+        }
+        else {
+            res.set(current, [filter[current]]);
+        }
+    });
+    return res;
+}

package/dist/esm/repositories/indexedDB/db.js

@@ -0,0 +1,4 @@
+import { DB_VERSION, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, STORE_TRANSACTIONS, STORE_UTXOS, STORE_VTXOS, STORE_WALLET_STATE, } from './schema.js';
+export { STORE_VTXOS, STORE_UTXOS, STORE_TRANSACTIONS, STORE_WALLET_STATE, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, DB_VERSION, };
+// Serialization helpers (re-exported from shared module)
+export { serializeTapLeaf, serializeVtxo, serializeUtxo, deserializeTapLeaf, deserializeVtxo, deserializeUtxo, } from '../serialization.js';

package/dist/esm/repositories/indexedDB/manager.js

@@ -0,0 +1,92 @@
+export function getGlobalObject() {
+    if (typeof globalThis !== "undefined") {
+        if (typeof globalThis.self === "object" && globalThis.self !== null) {
+            return { globalObject: globalThis.self };
+        }
+        if (typeof globalThis.window === "object" &&
+            globalThis.window !== null) {
+            return { globalObject: globalThis.window };
+        }
+        return { globalObject: globalThis };
+    }
+    throw new Error("Global object not found");
+}
+// database instance cache, avoiding multiple open requests
+const dbCache = new Map();
+// track reference counts for each database to avoid closing it prematurely
+const refCounts = new Map();
+/**
+ * Opens an IndexedDB database and increments the reference count.
+ * Handles global object detection and callbacks.
+ *
+ * @param dbName The name of the database to open.
+ * @param dbVersion The database version to open.
+ * @param initDatabase A function that migrates the database schema, called on `onupgradeneeded` only.
+ *
+ * @returns A promise that resolves to the database instance.
+ */
+export async function openDatabase(dbName, dbVersion, initDatabase) {
+    const { globalObject } = getGlobalObject();
+    if (!globalObject.indexedDB) {
+        throw new Error("IndexedDB is not available in this environment");
+    }
+    // Return cached promise if available (handles concurrent calls)
+    const cached = dbCache.get(dbName);
+    if (cached) {
+        if (cached.version !== dbVersion) {
+            throw new Error(`Database "${dbName}" already opened with version ${cached.version}; requested ${dbVersion}`);
+        }
+        refCounts.set(dbName, (refCounts.get(dbName) ?? 0) + 1);
+        return cached.promise;
+    }
+    const dbPromise = new Promise((resolve, reject) => {
+        const request = globalObject.indexedDB.open(dbName, dbVersion);
+        request.onerror = () => {
+            dbCache.delete(dbName); // Clean up on failure
+            refCounts.delete(dbName);
+            reject(request.error);
+        };
+        request.onsuccess = () => {
+            resolve(request.result);
+        };
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            initDatabase(db);
+        };
+        request.onblocked = () => {
+            console.warn("Database upgrade blocked - close other tabs/connections");
+        };
+    });
+    // Cache immediately before awaiting
+    dbCache.set(dbName, { version: dbVersion, promise: dbPromise });
+    refCounts.set(dbName, 1);
+    return dbPromise;
+}
+/**
+ * Decrements the reference count and closes the database when no references remain.
+ *
+ * @param dbName The name of the database to close.
+ *
+ * @returns True if the database was closed, false otherwise.
+ */
+export async function closeDatabase(dbName) {
+    const cachedEntry = dbCache.get(dbName);
+    if (!cachedEntry)
+        return false;
+    const count = (refCounts.get(dbName) ?? 1) - 1;
+    if (count > 0) {
+        refCounts.set(dbName, count);
+        return false;
+    }
+    // Last reference — actually close
+    refCounts.delete(dbName);
+    dbCache.delete(dbName);
+    try {
+        const db = await cachedEntry.promise;
+        db.close();
+    }
+    catch {
+        // DB failed to open, nothing to close
+    }
+    return true;
+}

package/dist/esm/repositories/indexedDB/schema.js

@@ -0,0 +1,155 @@
+// Store names introduced in V2, they are all new to the migration
+export const STORE_VTXOS = "vtxos";
+export const STORE_UTXOS = "utxos";
+export const STORE_TRANSACTIONS = "transactions";
+export const STORE_WALLET_STATE = "walletState";
+export const STORE_CONTRACTS = "contracts";
+// @deprecated use only for migrations, this is created in V1
+export const LEGACY_STORE_CONTRACT_COLLECTIONS = "contractsCollections";
+export const DB_VERSION = 2;
+export function initDatabase(db) {
+    // Create wallet stores
+    if (!db.objectStoreNames.contains(STORE_VTXOS)) {
+        const vtxosStore = db.createObjectStore(STORE_VTXOS, {
+            keyPath: ["address", "txid", "vout"],
+        });
+        if (!vtxosStore.indexNames.contains("address")) {
+            vtxosStore.createIndex("address", "address", {
+                unique: false,
+            });
+        }
+        if (!vtxosStore.indexNames.contains("txid")) {
+            vtxosStore.createIndex("txid", "txid", { unique: false });
+        }
+        if (!vtxosStore.indexNames.contains("value")) {
+            vtxosStore.createIndex("value", "value", { unique: false });
+        }
+        if (!vtxosStore.indexNames.contains("status")) {
+            vtxosStore.createIndex("status", "status", {
+                unique: false,
+            });
+        }
+        if (!vtxosStore.indexNames.contains("virtualStatus")) {
+            vtxosStore.createIndex("virtualStatus", "virtualStatus", {
+                unique: false,
+            });
+        }
+        if (!vtxosStore.indexNames.contains("createdAt")) {
+            vtxosStore.createIndex("createdAt", "createdAt", {
+                unique: false,
+            });
+        }
+        if (!vtxosStore.indexNames.contains("isSpent")) {
+            vtxosStore.createIndex("isSpent", "isSpent", {
+                unique: false,
+            });
+        }
+        if (!vtxosStore.indexNames.contains("isUnrolled")) {
+            vtxosStore.createIndex("isUnrolled", "isUnrolled", {
+                unique: false,
+            });
+        }
+        if (!vtxosStore.indexNames.contains("spentBy")) {
+            vtxosStore.createIndex("spentBy", "spentBy", {
+                unique: false,
+            });
+        }
+        if (!vtxosStore.indexNames.contains("settledBy")) {
+            vtxosStore.createIndex("settledBy", "settledBy", {
+                unique: false,
+            });
+        }
+        if (!vtxosStore.indexNames.contains("arkTxId")) {
+            vtxosStore.createIndex("arkTxId", "arkTxId", {
+                unique: false,
+            });
+        }
+    }
+    if (!db.objectStoreNames.contains(STORE_UTXOS)) {
+        const utxosStore = db.createObjectStore(STORE_UTXOS, {
+            keyPath: ["address", "txid", "vout"],
+        });
+        if (!utxosStore.indexNames.contains("address")) {
+            utxosStore.createIndex("address", "address", {
+                unique: false,
+            });
+        }
+        if (!utxosStore.indexNames.contains("txid")) {
+            utxosStore.createIndex("txid", "txid", { unique: false });
+        }
+        if (!utxosStore.indexNames.contains("value")) {
+            utxosStore.createIndex("value", "value", { unique: false });
+        }
+        if (!utxosStore.indexNames.contains("status")) {
+            utxosStore.createIndex("status", "status", {
+                unique: false,
+            });
+        }
+    }
+    if (!db.objectStoreNames.contains(STORE_TRANSACTIONS)) {
+        const transactionsStore = db.createObjectStore(STORE_TRANSACTIONS, {
+            keyPath: [
+                "address",
+                "keyBoardingTxid",
+                "keyCommitmentTxid",
+                "keyArkTxid",
+            ],
+        });
+        if (!transactionsStore.indexNames.contains("address")) {
+            transactionsStore.createIndex("address", "address", {
+                unique: false,
+            });
+        }
+        if (!transactionsStore.indexNames.contains("type")) {
+            transactionsStore.createIndex("type", "type", {
+                unique: false,
+            });
+        }
+        if (!transactionsStore.indexNames.contains("amount")) {
+            transactionsStore.createIndex("amount", "amount", {
+                unique: false,
+            });
+        }
+        if (!transactionsStore.indexNames.contains("settled")) {
+            transactionsStore.createIndex("settled", "settled", {
+                unique: false,
+            });
+        }
+        if (!transactionsStore.indexNames.contains("createdAt")) {
+            transactionsStore.createIndex("createdAt", "createdAt", {
+                unique: false,
+            });
+        }
+        if (!transactionsStore.indexNames.contains("arkTxid")) {
+            transactionsStore.createIndex("arkTxid", "key.arkTxid", {
+                unique: false,
+            });
+        }
+    }
+    if (!db.objectStoreNames.contains(STORE_WALLET_STATE)) {
+        db.createObjectStore(STORE_WALLET_STATE, {
+            keyPath: "key",
+        });
+    }
+    // Create contract stores
+    if (!db.objectStoreNames.contains(STORE_CONTRACTS)) {
+        const contractsStore = db.createObjectStore(STORE_CONTRACTS, {
+            keyPath: "script",
+        });
+        if (!contractsStore.indexNames.contains("type")) {
+            contractsStore.createIndex("type", "type", {
+                unique: false,
+            });
+        }
+        if (!contractsStore.indexNames.contains("state")) {
+            contractsStore.createIndex("state", "state", {
+                unique: false,
+            });
+        }
+    }
+    if (!db.objectStoreNames.contains(LEGACY_STORE_CONTRACT_COLLECTIONS)) {
+        db.createObjectStore(LEGACY_STORE_CONTRACT_COLLECTIONS, {
+            keyPath: "key",
+        });
+    }
+}