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

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

@@ -0,0 +1,334 @@
+import { STORE_VTXOS, STORE_UTXOS, STORE_TRANSACTIONS, STORE_WALLET_STATE, serializeVtxo, serializeUtxo, deserializeVtxo, deserializeUtxo, DB_VERSION, } 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 WalletRepository.
+ */
+export class IndexedDBWalletRepository {
+    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_VTXOS,
+                    STORE_UTXOS,
+                    STORE_TRANSACTIONS,
+                    STORE_WALLET_STATE,
+                ], "readwrite");
+                const vtxosStore = transaction.objectStore(STORE_VTXOS);
+                const utxosStore = transaction.objectStore(STORE_UTXOS);
+                const transactionsStore = transaction.objectStore(STORE_TRANSACTIONS);
+                const walletStateStore = transaction.objectStore(STORE_WALLET_STATE);
+                const requests = [
+                    vtxosStore.clear(),
+                    utxosStore.clear(),
+                    transactionsStore.clear(),
+                    walletStateStore.clear(),
+                ];
+                let completed = 0;
+                const checkComplete = () => {
+                    completed++;
+                    if (completed === requests.length) {
+                        resolve();
+                    }
+                };
+                requests.forEach((request) => {
+                    request.onsuccess = checkComplete;
+                    request.onerror = () => reject(request.error);
+                });
+            });
+        }
+        catch (error) {
+            console.error("Failed to clear wallet data:", error);
+            throw error;
+        }
+    }
+    async [Symbol.asyncDispose]() {
+        if (!this.db)
+            return;
+        await closeDatabase(this.dbName);
+        this.db = null;
+    }
+    async getVtxos(address) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_VTXOS], "readonly");
+                const store = transaction.objectStore(STORE_VTXOS);
+                const index = store.index("address");
+                const request = index.getAll(address);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => {
+                    const results = request.result || [];
+                    const vtxos = results.map(deserializeVtxo);
+                    resolve(vtxos);
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to get VTXOs for address ${address}:`, error);
+            return [];
+        }
+    }
+    async saveVtxos(address, vtxos) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_VTXOS], "readwrite");
+                const store = transaction.objectStore(STORE_VTXOS);
+                const promises = vtxos.map((vtxo) => {
+                    return new Promise((resolveItem, rejectItem) => {
+                        const serialized = serializeVtxo(vtxo);
+                        const item = {
+                            address,
+                            ...serialized,
+                        };
+                        const request = store.put(item);
+                        request.onerror = () => rejectItem(request.error);
+                        request.onsuccess = () => resolveItem();
+                    });
+                });
+                Promise.all(promises)
+                    .then(() => resolve())
+                    .catch(reject);
+                transaction.onerror = () => reject(transaction.error);
+            });
+        }
+        catch (error) {
+            console.error(`Failed to save VTXOs for address ${address}:`, error);
+            throw error;
+        }
+    }
+    async deleteVtxos(address) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_VTXOS], "readwrite");
+                const store = transaction.objectStore(STORE_VTXOS);
+                const index = store.index("address");
+                const request = index.openCursor(IDBKeyRange.only(address));
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => {
+                    const cursor = request.result;
+                    if (cursor) {
+                        cursor.delete();
+                        cursor.continue();
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to clear VTXOs for address ${address}:`, error);
+            throw error;
+        }
+    }
+    async getUtxos(address) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_UTXOS], "readonly");
+                const store = transaction.objectStore(STORE_UTXOS);
+                const index = store.index("address");
+                const request = index.getAll(address);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => {
+                    const results = request.result || [];
+                    const utxos = results.map(deserializeUtxo);
+                    resolve(utxos);
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to get UTXOs for address ${address}:`, error);
+            return [];
+        }
+    }
+    async saveUtxos(address, utxos) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_UTXOS], "readwrite");
+                const store = transaction.objectStore(STORE_UTXOS);
+                const promises = utxos.map((utxo) => {
+                    return new Promise((resolveItem, rejectItem) => {
+                        const serialized = serializeUtxo(utxo);
+                        const item = {
+                            address,
+                            ...serialized,
+                        };
+                        const request = store.put(item);
+                        request.onerror = () => rejectItem(request.error);
+                        request.onsuccess = () => resolveItem();
+                    });
+                });
+                Promise.all(promises)
+                    .then(() => resolve())
+                    .catch(reject);
+                transaction.onerror = () => reject(transaction.error);
+            });
+        }
+        catch (error) {
+            console.error(`Failed to save UTXOs for address ${address}:`, error);
+            throw error;
+        }
+    }
+    async deleteUtxos(address) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_UTXOS], "readwrite");
+                const store = transaction.objectStore(STORE_UTXOS);
+                const index = store.index("address");
+                const request = index.openCursor(IDBKeyRange.only(address));
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => {
+                    const cursor = request.result;
+                    if (cursor) {
+                        cursor.delete();
+                        cursor.continue();
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to clear UTXOs for address ${address}:`, error);
+            throw error;
+        }
+    }
+    async getTransactionHistory(address) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_TRANSACTIONS], "readonly");
+                const store = transaction.objectStore(STORE_TRANSACTIONS);
+                const index = store.index("address");
+                const request = index.getAll(address);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => {
+                    const results = request.result || [];
+                    resolve(results.sort((a, b) => a.createdAt - b.createdAt));
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to get transaction history for address ${address}:`, error);
+            return [];
+        }
+    }
+    async saveTransactions(address, txs) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_TRANSACTIONS], "readwrite");
+                const store = transaction.objectStore(STORE_TRANSACTIONS);
+                // Queue all put operations
+                txs.forEach((tx) => {
+                    const item = {
+                        address,
+                        ...tx,
+                        keyBoardingTxid: tx.key.boardingTxid,
+                        keyCommitmentTxid: tx.key.commitmentTxid,
+                        keyArkTxid: tx.key.arkTxid,
+                    };
+                    store.put(item);
+                });
+                // Handle transaction completion
+                transaction.oncomplete = () => resolve();
+                transaction.onerror = () => reject(transaction.error);
+                transaction.onabort = () => reject(new Error("Transaction aborted"));
+            });
+        }
+        catch (error) {
+            console.error(`Failed to save transactions for address ${address}:`, error);
+            throw error;
+        }
+    }
+    async deleteTransactions(address) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_TRANSACTIONS], "readwrite");
+                const store = transaction.objectStore(STORE_TRANSACTIONS);
+                const index = store.index("address");
+                const request = index.openCursor(IDBKeyRange.only(address));
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => {
+                    const cursor = request.result;
+                    if (cursor) {
+                        cursor.delete();
+                        cursor.continue();
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to clear transactions for address ${address}:`, error);
+            throw error;
+        }
+    }
+    async getWalletState() {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_WALLET_STATE], "readonly");
+                const store = transaction.objectStore(STORE_WALLET_STATE);
+                const request = store.get("state");
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => {
+                    const result = request.result;
+                    if (result && result.data) {
+                        resolve(result.data);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                };
+            });
+        }
+        catch (error) {
+            console.error("Failed to get wallet state:", error);
+            return null;
+        }
+    }
+    async saveWalletState(state) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_WALLET_STATE], "readwrite");
+                const store = transaction.objectStore(STORE_WALLET_STATE);
+                const item = {
+                    key: "state",
+                    data: state,
+                };
+                const request = store.put(item);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve();
+            });
+        }
+        catch (error) {
+            console.error("Failed to save wallet state:", error);
+            throw error;
+        }
+    }
+    async getDB() {
+        if (this.db)
+            return this.db;
+        this.db = await openDatabase(this.dbName, DB_VERSION, initDatabase);
+        return this.db;
+    }
+}

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

@@ -0,0 +1,138 @@
+/**
+ * WebSQL adapter over expo-sqlite.
+ *
+ * Bridges the WebSQL API surface that indexeddbshim expects to the
+ * synchronous expo-sqlite driver.  Only the subset actually called by
+ * the shim is implemented:
+ *
+ *   openDatabase(name, version, displayName, estimatedSize) → WebSQLDatabase
+ *   db.transaction(cb, errCb?, successCb?)
+ *   tx.executeSql(sql, args?, successCb?, errorCb?)
+ *   resultSet = { insertId, rowsAffected, rows: { length, item(i) } }
+ */
+import { openDatabaseSync } from "expo-sqlite";
+// ── Database cache ───────────────────────────────────────────────────
+const dbCache = new Map();
+function getSqliteDb(name) {
+    let db = dbCache.get(name);
+    if (db)
+        return { db, created: false };
+    db = openDatabaseSync(name);
+    dbCache.set(name, db);
+    return { db, created: true };
+}
+// ── WebSQLTransaction ────────────────────────────────────────────────
+export class WebSQLTransaction {
+    constructor() {
+        /** @internal */
+        this._queue = [];
+    }
+    executeSql(sql, args, successCb, errorCb) {
+        this._queue.push({ sql, args: args ?? [], successCb, errorCb });
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────
+function isRead(sql) {
+    const trimmed = sql.trimStart().toUpperCase();
+    return trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA");
+}
+function buildResultSet(db, sql, args) {
+    if (isRead(sql)) {
+        const rows = db.getAllSync(sql, args);
+        return {
+            insertId: 0,
+            rowsAffected: 0,
+            rows: {
+                length: rows.length,
+                item(i) {
+                    return rows[i];
+                },
+            },
+        };
+    }
+    const result = db.runSync(sql, args);
+    return {
+        insertId: result.lastInsertRowId,
+        rowsAffected: result.changes,
+        rows: {
+            length: 0,
+            item(_i) {
+                return undefined;
+            },
+        },
+    };
+}
+function drainQueue(db, tx) {
+    // Process until the queue is empty.  Success callbacks may enqueue
+    // more statements, so we loop rather than iterate a snapshot.
+    while (tx._queue.length > 0) {
+        const stmt = tx._queue.shift();
+        try {
+            const rs = buildResultSet(db, stmt.sql, stmt.args);
+            if (stmt.successCb) {
+                stmt.successCb(tx, rs);
+            }
+        }
+        catch (err) {
+            const sqlError = {
+                code: 0,
+                message: err?.message ?? String(err),
+            };
+            if (stmt.errorCb) {
+                const shouldContinue = stmt.errorCb(tx, sqlError);
+                if (shouldContinue === true) {
+                    // Error handler returned true → swallow error and continue
+                    continue;
+                }
+            }
+            // Abort the transaction
+            throw err;
+        }
+    }
+}
+// ── WebSQLDatabase ───────────────────────────────────────────────────
+export class WebSQLDatabase {
+    constructor(db, version) {
+        this._db = db;
+        this.version = version;
+    }
+    transaction(callback, errorCb, successCb) {
+        // WebSQL is async/callback-based.  Schedule via macrotask so the
+        // caller's subsequent code runs first (matches browser behavior).
+        setTimeout(() => {
+            const tx = new WebSQLTransaction();
+            try {
+                // Let the caller enqueue statements
+                callback(tx);
+                // Execute everything inside a real SQLite transaction
+                this._db.withTransactionSync(() => {
+                    drainQueue(this._db, tx);
+                });
+                if (successCb)
+                    successCb();
+            }
+            catch (err) {
+                const sqlError = {
+                    code: 0,
+                    message: err?.message ?? String(err),
+                };
+                if (errorCb) {
+                    errorCb(sqlError);
+                }
+            }
+        }, 0);
+    }
+    readTransaction(callback, errorCb, successCb) {
+        // Reads go through the same path — SQLite handles concurrency.
+        this.transaction(callback, errorCb, successCb);
+    }
+}
+// ── openDatabase (WebSQL entry point) ────────────────────────────────
+export function openDatabase(name, version, _displayName, _estimatedSize, _creationCallback) {
+    const { db: sqliteDb, created } = getSqliteDb(name);
+    const wsdb = new WebSQLDatabase(sqliteDb, version);
+    if (created && _creationCallback) {
+        _creationCallback(wsdb);
+    }
+    return wsdb;
+}

package/dist/esm/repositories/migrations/contractRepositoryImpl.js

@@ -0,0 +1,121 @@
+export const getContractStorageKey = (id, key) => `contract:${id}:${key}`;
+export const getCollectionStorageKey = (type) => `collection:${type}`;
+/**
+ * @deprecated This is only to be used in migration from storage V1
+ */
+export class ContractRepositoryImpl {
+    constructor(storage) {
+        this.version = 1;
+        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
+        }
+    }
+    // The following methods are implemented for compatibility with the new ContractRepository interface
+    // but aren't used.
+    async getContracts(_) {
+        throw new TypeError("Method not implemented, this is a legacy class and should only be used for migrating data.");
+    }
+    async saveContract(_) {
+        throw new TypeError("Method not implemented, this is a legacy class and should only be used for migrating data.");
+    }
+    async deleteContract(_) {
+        throw new TypeError("Method not implemented, this is a legacy class and should only be used for migrating data.");
+    }
+    // used only for tests
+    async clear() {
+        await this.storage.clear();
+    }
+    async [Symbol.asyncDispose]() {
+        // deprecated StorageAdapter doesn't have a `close()` method
+        return;
+    }
+}

package/dist/esm/repositories/migrations/fromStorageAdapter.js

@@ -0,0 +1,58 @@
+import { WalletRepositoryImpl } from './walletRepositoryImpl.js';
+export const MIGRATION_KEY = (repoType) => `migration-from-storage-adapter-${repoType}`;
+export async function getMigrationStatus(repoType, storageAdapter) {
+    try {
+        const migration = await storageAdapter.getItem(MIGRATION_KEY(repoType));
+        if (migration === "done")
+            return "done";
+        if (migration === "in-progress")
+            return "in-progress";
+        return "pending";
+    }
+    catch (e) {
+        if (e instanceof DOMException && e.name === "NotFoundError")
+            return "not-needed";
+        throw e;
+    }
+}
+export async function requiresMigration(repoType, storageAdapter) {
+    const status = await getMigrationStatus(repoType, storageAdapter);
+    return status === "pending" || status === "in-progress";
+}
+export async function rollbackMigration(repoType, storageAdapter) {
+    await storageAdapter.removeItem(MIGRATION_KEY(repoType));
+}
+/**
+ * Migrate wallet data from the legacy storage adapter to the new one.
+ * It accepts both onchain and offchain addresses, make sure to pass both.
+ *
+ * @param storageAdapter
+ * @param fresh
+ * @param addresses
+ */
+export async function migrateWalletRepository(storageAdapter, fresh, addresses) {
+    const migrate = await requiresMigration("wallet", storageAdapter);
+    if (!migrate)
+        return;
+    await storageAdapter.setItem(MIGRATION_KEY("wallet"), "in-progress");
+    const old = new WalletRepositoryImpl(storageAdapter);
+    const walletData = await old.getWalletState();
+    const onchainAddrData = await Promise.all(addresses.onchain.map(async (address) => {
+        const utxos = await old.getUtxos(address);
+        return { address, utxos };
+    }));
+    const offchainAddrData = await Promise.all(addresses.offchain.map(async (address) => {
+        const vtxos = await old.getVtxos(address);
+        const txs = await old.getTransactionHistory(address);
+        return { address, vtxos, txs };
+    }));
+    await Promise.all([
+        walletData && fresh.saveWalletState(walletData),
+        ...offchainAddrData.map((addressData) => Promise.all([
+            fresh.saveVtxos(addressData.address, addressData.vtxos),
+            fresh.saveTransactions(addressData.address, addressData.txs),
+        ])),
+        ...onchainAddrData.map((addressData) => fresh.saveUtxos(addressData.address, addressData.utxos)),
+    ]);
+    await storageAdapter.setItem(MIGRATION_KEY("wallet"), "done");
+}