@arkade-os/sdk 0.4.27 → 0.4.28

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

@@ -1,470 +0,0 @@
-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 { scriptFromArkAddress } from "../scriptFromAddress.js";
-import { DEFAULT_DB_NAME } from "../../worker/browser/utils.js";
-import { isVtxoForScript } from "../../contracts/vtxoOwnership.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 || [];
-                    // Wrap `.map` in try/catch so a bad row (e.g. a legacy
-                    // VTXO whose address can't be decoded during backfill)
-                    // rejects the promise instead of silently throwing
-                    // inside the IDB event handler, which would otherwise
-                    // hang the caller.
-                    try {
-                        resolve(results.map(deserializeVtxoWithBackfill));
-                    }
-                    catch (err) {
-                        reject(err);
-                    }
-                };
-            });
-        }
-        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 getVtxosForScript(script) {
-        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("script");
-                const request = index.getAll(script);
-                request.onerror = () => reject(request.error);
-                request.onsuccess = () => {
-                    const results = request.result || [];
-                    try {
-                        // Defensive filter: only rows whose script matches.
-                        const matching = results.filter((r) => r.script === script);
-                        // Dedup same outpoint rows across address buckets.
-                        // Work on raw rows so the address field is available
-                        // for the canonicality tiebreaker.
-                        const byOutpoint = new Map();
-                        for (const row of matching) {
-                            const outpoint = `${row.txid}:${row.vout}`;
-                            const existing = byOutpoint.get(outpoint);
-                            if (!existing) {
-                                byOutpoint.set(outpoint, row);
-                                continue;
-                            }
-                            if (shouldReplaceVtxo(existing, row)) {
-                                byOutpoint.set(outpoint, row);
-                            }
-                        }
-                        resolve(Array.from(byOutpoint.values()).map(deserializeVtxoWithBackfill));
-                    }
-                    catch (err) {
-                        reject(err);
-                    }
-                };
-            });
-        }
-        catch (error) {
-            console.error(`Failed to get VTXOs for script ${script}:`, error);
-            throw error;
-        }
-    }
-    async saveVtxosForScript(key, vtxos) {
-        if (!key.address) {
-            throw new Error("IndexedDBWalletRepository requires an address");
-        }
-        for (const vtxo of vtxos) {
-            if (!isVtxoForScript(vtxo, key.script)) {
-                throw new Error(`VTXO ${vtxo.txid}:${vtxo.vout} script mismatch: expected ${key.script}, got ${vtxo.script}`);
-            }
-        }
-        return this.saveVtxos(key.address, vtxos);
-    }
-    async deleteVtxosForScript(script) {
-        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("script");
-                const request = index.openCursor(IDBKeyRange.only(script));
-                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 script ${script}:`, 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;
-    }
-}
-// Post-migration every row has `script`, but the backfill is idempotent: if a
-// legacy row is ever read before the upgrade-path completes, derive `script`
-// from `address` the same way the indexer would have populated it.
-function deserializeVtxoWithBackfill(o) {
-    if (!o.script) {
-        o = { ...o, script: scriptFromArkAddress(o.address) };
-    }
-    return deserializeVtxo(o);
-}
-function isCanonicalRow(row) {
-    try {
-        return scriptFromArkAddress(row.address) === row.script;
-    }
-    catch {
-        return false;
-    }
-}
-function shouldReplaceVtxo(existing, incoming) {
-    const existingCanonical = isCanonicalRow(existing);
-    const incomingCanonical = isCanonicalRow(incoming);
-    if (incomingCanonical && !existingCanonical)
-        return true;
-    if (existingCanonical && !incomingCanonical)
-        return false;
-    // Tie on canonicality, check lifecycle completeness
-    const existingWeight = getLifecycleWeight(existing);
-    const incomingWeight = getLifecycleWeight(incoming);
-    if (incomingWeight > existingWeight)
-        return true;
-    if (existingWeight > incomingWeight)
-        return false;
-    // Tie on weight, stable sort by address
-    return incoming.address < existing.address;
-}
-function getLifecycleWeight(v) {
-    let weight = 0;
-    if (v.isSpent !== undefined)
-        weight += 1;
-    if (v.spentBy)
-        weight += 2;
-    if (v.settledBy)
-        weight += 2;
-    if (v.arkTxId)
-        weight += 2;
-    return weight;
-}

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

@@ -1,138 +0,0 @@
-/**
- * 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;
-}