@arkade-os/sdk 0.3.12 → 0.4.0-next.0

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DB_VERSION = exports.LEGACY_STORE_CONTRACT_COLLECTIONS = exports.STORE_CONTRACTS = exports.STORE_WALLET_STATE = exports.STORE_TRANSACTIONS = exports.STORE_UTXOS = exports.STORE_VTXOS = void 0;
+exports.initDatabase = initDatabase;
+// Store names introduced in V2, they are all new to the migration
+exports.STORE_VTXOS = "vtxos";
+exports.STORE_UTXOS = "utxos";
+exports.STORE_TRANSACTIONS = "transactions";
+exports.STORE_WALLET_STATE = "walletState";
+exports.STORE_CONTRACTS = "contracts";
+// @deprecated use only for migrations, this is created in V1
+exports.LEGACY_STORE_CONTRACT_COLLECTIONS = "contractsCollections";
+exports.DB_VERSION = 2;
+function initDatabase(db) {
+    // Create wallet stores
+    if (!db.objectStoreNames.contains(exports.STORE_VTXOS)) {
+        const vtxosStore = db.createObjectStore(exports.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(exports.STORE_UTXOS)) {
+        const utxosStore = db.createObjectStore(exports.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(exports.STORE_TRANSACTIONS)) {
+        const transactionsStore = db.createObjectStore(exports.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(exports.STORE_WALLET_STATE)) {
+        db.createObjectStore(exports.STORE_WALLET_STATE, {
+            keyPath: "key",
+        });
+    }
+    // Create contract stores
+    if (!db.objectStoreNames.contains(exports.STORE_CONTRACTS)) {
+        const contractsStore = db.createObjectStore(exports.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(exports.LEGACY_STORE_CONTRACT_COLLECTIONS)) {
+        db.createObjectStore(exports.LEGACY_STORE_CONTRACT_COLLECTIONS, {
+            keyPath: "key",
+        });
+    }
+}

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

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedDBWalletRepository = void 0;
+const db_1 = require("./db");
+const manager_1 = require("../../db/manager");
+const schema_1 = require("./schema");
+const utils_1 = require("../../worker/browser/utils");
+/**
+ * IndexedDB-based implementation of WalletRepository.
+ */
+class IndexedDBWalletRepository {
+    constructor(dbName = utils_1.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([
+                    db_1.STORE_VTXOS,
+                    db_1.STORE_UTXOS,
+                    db_1.STORE_TRANSACTIONS,
+                    db_1.STORE_WALLET_STATE,
+                ], "readwrite");
+                const vtxosStore = transaction.objectStore(db_1.STORE_VTXOS);
+                const utxosStore = transaction.objectStore(db_1.STORE_UTXOS);
+                const transactionsStore = transaction.objectStore(db_1.STORE_TRANSACTIONS);
+                const walletStateStore = transaction.objectStore(db_1.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 (0, manager_1.closeDatabase)(this.dbName);
+        this.db = null;
+    }
+    async getVtxos(address) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([db_1.STORE_VTXOS], "readonly");
+                const store = transaction.objectStore(db_1.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(db_1.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([db_1.STORE_VTXOS], "readwrite");
+                const store = transaction.objectStore(db_1.STORE_VTXOS);
+                const promises = vtxos.map((vtxo) => {
+                    return new Promise((resolveItem, rejectItem) => {
+                        const serialized = (0, db_1.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([db_1.STORE_VTXOS], "readwrite");
+                const store = transaction.objectStore(db_1.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([db_1.STORE_UTXOS], "readonly");
+                const store = transaction.objectStore(db_1.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(db_1.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([db_1.STORE_UTXOS], "readwrite");
+                const store = transaction.objectStore(db_1.STORE_UTXOS);
+                const promises = utxos.map((utxo) => {
+                    return new Promise((resolveItem, rejectItem) => {
+                        const serialized = (0, db_1.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([db_1.STORE_UTXOS], "readwrite");
+                const store = transaction.objectStore(db_1.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([db_1.STORE_TRANSACTIONS], "readonly");
+                const store = transaction.objectStore(db_1.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([db_1.STORE_TRANSACTIONS], "readwrite");
+                const store = transaction.objectStore(db_1.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([db_1.STORE_TRANSACTIONS], "readwrite");
+                const store = transaction.objectStore(db_1.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([db_1.STORE_WALLET_STATE], "readonly");
+                const store = transaction.objectStore(db_1.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([db_1.STORE_WALLET_STATE], "readwrite");
+                const store = transaction.objectStore(db_1.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 (0, manager_1.openDatabase)(this.dbName, db_1.DB_VERSION, schema_1.initDatabase);
+        return this.db;
+    }
+}
+exports.IndexedDBWalletRepository = IndexedDBWalletRepository;

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

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * 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) } }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSQLDatabase = exports.WebSQLTransaction = void 0;
+exports.openDatabase = openDatabase;
+const expo_sqlite_1 = require("expo-sqlite");
+// ── Database cache ───────────────────────────────────────────────────
+const dbCache = new Map();
+function getSqliteDb(name) {
+    let db = dbCache.get(name);
+    if (db)
+        return { db, created: false };
+    db = (0, expo_sqlite_1.openDatabaseSync)(name);
+    dbCache.set(name, db);
+    return { db, created: true };
+}
+// ── WebSQLTransaction ────────────────────────────────────────────────
+class WebSQLTransaction {
+    constructor() {
+        /** @internal */
+        this._queue = [];
+    }
+    executeSql(sql, args, successCb, errorCb) {
+        this._queue.push({ sql, args: args ?? [], successCb, errorCb });
+    }
+}
+exports.WebSQLTransaction = WebSQLTransaction;
+// ── 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 ───────────────────────────────────────────────────
+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);
+    }
+}
+exports.WebSQLDatabase = WebSQLDatabase;
+// ── openDatabase (WebSQL entry point) ────────────────────────────────
+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;
+}