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

package/dist/esm/repositories/serialization.js

@@ -0,0 +1,40 @@
+import { hex } from "@scure/base";
+import { TaprootControlBlock } from "@scure/btc-signer";
+export const serializeTapLeaf = ([cb, s,]) => ({
+    cb: hex.encode(TaprootControlBlock.encode(cb)),
+    s: hex.encode(s),
+});
+export const serializeVtxo = (v) => ({
+    ...v,
+    tapTree: hex.encode(v.tapTree),
+    forfeitTapLeafScript: serializeTapLeaf(v.forfeitTapLeafScript),
+    intentTapLeafScript: serializeTapLeaf(v.intentTapLeafScript),
+    extraWitness: v.extraWitness?.map(hex.encode),
+});
+export const serializeUtxo = (u) => ({
+    ...u,
+    tapTree: hex.encode(u.tapTree),
+    forfeitTapLeafScript: serializeTapLeaf(u.forfeitTapLeafScript),
+    intentTapLeafScript: serializeTapLeaf(u.intentTapLeafScript),
+    extraWitness: u.extraWitness?.map(hex.encode),
+});
+export const deserializeTapLeaf = (t) => {
+    const cb = TaprootControlBlock.decode(hex.decode(t.cb));
+    const s = hex.decode(t.s);
+    return [cb, s];
+};
+export const deserializeVtxo = (o) => ({
+    ...o,
+    createdAt: new Date(o.createdAt),
+    tapTree: hex.decode(o.tapTree),
+    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
+    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
+    extraWitness: o.extraWitness?.map(hex.decode),
+});
+export const deserializeUtxo = (o) => ({
+    ...o,
+    tapTree: hex.decode(o.tapTree),
+    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
+    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
+    extraWitness: o.extraWitness?.map(hex.decode),
+});

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

@@ -0,0 +1,135 @@
+/**
+ * SQLite-based implementation of ContractRepository.
+ *
+ * Uses the SQLExecutor interface so consumers can plug in any SQLite driver
+ * (expo-sqlite, better-sqlite3, etc.).
+ *
+ * Tables are created lazily on first operation via `ensureInit()`.
+ * The consumer owns the SQLExecutor lifecycle — `[Symbol.asyncDispose]` is a no-op.
+ */
+export class SQLiteContractRepository {
+    constructor(db, options) {
+        this.db = db;
+        this.version = 1;
+        this.initPromise = null;
+        this.prefix = sanitizePrefix(options?.prefix ?? "ark_");
+        this.table = `${this.prefix}contracts`;
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────
+    ensureInit() {
+        if (!this.initPromise) {
+            this.initPromise = this.init();
+        }
+        return this.initPromise;
+    }
+    async init() {
+        await this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.table} (
+                script TEXT PRIMARY KEY,
+                address TEXT NOT NULL,
+                type TEXT NOT NULL,
+                state TEXT NOT NULL,
+                params_json TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                expires_at INTEGER,
+                label TEXT,
+                metadata_json TEXT
+            )
+        `);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_${this.prefix}contracts_type ON ${this.table} (type)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_${this.prefix}contracts_state ON ${this.table} (state)`);
+    }
+    async [Symbol.asyncDispose]() {
+        // no-op — consumer owns the SQLExecutor lifecycle
+    }
+    // ── Clear ──────────────────────────────────────────────────────────
+    async clear() {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.table}`);
+    }
+    // ── Contract management ────────────────────────────────────────────
+    async getContracts(filter) {
+        await this.ensureInit();
+        const conditions = [];
+        const params = [];
+        if (filter) {
+            this.addFilterCondition(conditions, params, "script", filter.script);
+            this.addFilterCondition(conditions, params, "state", filter.state);
+            this.addFilterCondition(conditions, params, "type", filter.type);
+        }
+        let sql = `SELECT * FROM ${this.table}`;
+        if (conditions.length > 0) {
+            sql += ` WHERE ${conditions.join(" AND ")}`;
+        }
+        const rows = await this.db.all(sql, params);
+        return rows.map(contractRowToDomain);
+    }
+    async saveContract(contract) {
+        await this.ensureInit();
+        await this.db.run(`INSERT OR REPLACE INTO ${this.table}
+                (script, address, type, state, params_json,
+                 created_at, expires_at, label, metadata_json)
+             VALUES (?, ?, ?, ?, ?,
+                     ?, ?, ?, ?)`, [
+            contract.script,
+            contract.address,
+            contract.type,
+            contract.state,
+            JSON.stringify(contract.params),
+            contract.createdAt,
+            contract.expiresAt ?? null,
+            contract.label ?? null,
+            contract.metadata ? JSON.stringify(contract.metadata) : null,
+        ]);
+    }
+    async deleteContract(script) {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.table} WHERE script = ?`, [
+            script,
+        ]);
+    }
+    // ── Helpers ─────────────────────────────────────────────────────────
+    addFilterCondition(conditions, params, column, value) {
+        if (value === undefined)
+            return;
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                return;
+            const placeholders = value.map(() => "?").join(", ");
+            conditions.push(`${column} IN (${placeholders})`);
+            params.push(...value);
+        }
+        else {
+            conditions.push(`${column} = ?`);
+            params.push(value);
+        }
+    }
+}
+// ── Row → Domain converter ──────────────────────────────────────────────
+const SAFE_PREFIX = /^[a-zA-Z0-9_]+$/;
+function sanitizePrefix(prefix) {
+    if (!SAFE_PREFIX.test(prefix)) {
+        throw new Error(`Invalid table prefix "${prefix}": only letters, digits, and underscores are allowed`);
+    }
+    return prefix;
+}
+function contractRowToDomain(row) {
+    const contract = {
+        script: row.script,
+        address: row.address,
+        type: row.type,
+        state: row.state,
+        params: JSON.parse(row.params_json),
+        createdAt: row.created_at,
+    };
+    if (row.expires_at !== null) {
+        contract.expiresAt = row.expires_at;
+    }
+    if (row.label !== null) {
+        contract.label = row.label;
+    }
+    if (row.metadata_json !== null) {
+        contract.metadata = JSON.parse(row.metadata_json);
+    }
+    return contract;
+}

package/dist/esm/repositories/sqlite/index.js

@@ -0,0 +1,2 @@
+export { SQLiteWalletRepository } from './walletRepository.js';
+export { SQLiteContractRepository } from './contractRepository.js';

package/dist/esm/repositories/sqlite/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,324 @@
+import { serializeVtxo, serializeUtxo, deserializeVtxo, deserializeUtxo, } from '../serialization.js';
+/**
+ * SQLite-based implementation of WalletRepository.
+ *
+ * Uses the SQLExecutor interface so consumers can plug in any SQLite driver
+ * (expo-sqlite, better-sqlite3, etc.).
+ *
+ * Tables are created lazily on first operation via `ensureInit()`.
+ * The consumer owns the SQLExecutor lifecycle — `[Symbol.asyncDispose]` is a no-op.
+ */
+export class SQLiteWalletRepository {
+    constructor(db, options) {
+        this.db = db;
+        this.version = 1;
+        this.initPromise = null;
+        this.prefix = sanitizePrefix(options?.prefix ?? "ark_");
+        this.tables = {
+            vtxos: `${this.prefix}vtxos`,
+            utxos: `${this.prefix}utxos`,
+            transactions: `${this.prefix}transactions`,
+            walletState: `${this.prefix}wallet_state`,
+        };
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────
+    ensureInit() {
+        if (!this.initPromise) {
+            this.initPromise = this.init();
+        }
+        return this.initPromise;
+    }
+    async init() {
+        await this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.tables.vtxos} (
+                txid TEXT NOT NULL,
+                vout INTEGER NOT NULL,
+                value INTEGER NOT NULL,
+                address TEXT NOT NULL,
+                tap_tree TEXT NOT NULL,
+                forfeit_cb TEXT NOT NULL,
+                forfeit_s TEXT NOT NULL,
+                intent_cb TEXT NOT NULL,
+                intent_s TEXT NOT NULL,
+                status_json TEXT NOT NULL,
+                virtual_status_json TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                is_unrolled INTEGER NOT NULL DEFAULT 0,
+                is_spent INTEGER,
+                spent_by TEXT,
+                settled_by TEXT,
+                ark_tx_id TEXT,
+                extra_witness_json TEXT,
+                assets_json TEXT,
+                PRIMARY KEY (txid, vout)
+            )
+        `);
+        await this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.tables.utxos} (
+                txid TEXT NOT NULL,
+                vout INTEGER NOT NULL,
+                value INTEGER NOT NULL,
+                address TEXT NOT NULL,
+                tap_tree TEXT NOT NULL,
+                forfeit_cb TEXT NOT NULL,
+                forfeit_s TEXT NOT NULL,
+                intent_cb TEXT NOT NULL,
+                intent_s TEXT NOT NULL,
+                status_json TEXT NOT NULL,
+                extra_witness_json TEXT,
+                PRIMARY KEY (txid, vout)
+            )
+        `);
+        await this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.tables.transactions} (
+                address TEXT NOT NULL,
+                boarding_txid TEXT NOT NULL,
+                commitment_txid TEXT NOT NULL,
+                ark_txid TEXT NOT NULL,
+                type TEXT NOT NULL,
+                amount INTEGER NOT NULL,
+                settled INTEGER NOT NULL DEFAULT 0,
+                created_at INTEGER NOT NULL,
+                assets_json TEXT,
+                PRIMARY KEY (address, boarding_txid, commitment_txid, ark_txid)
+            )
+        `);
+        await this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.tables.walletState} (
+                key TEXT PRIMARY KEY,
+                last_sync_time INTEGER,
+                settings_json TEXT
+            )
+        `);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_${this.prefix}vtxos_address ON ${this.tables.vtxos} (address)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_${this.prefix}utxos_address ON ${this.tables.utxos} (address)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_${this.prefix}transactions_address ON ${this.tables.transactions} (address)`);
+    }
+    async [Symbol.asyncDispose]() {
+        // no-op — consumer owns the SQLExecutor lifecycle
+    }
+    // ── Clear ──────────────────────────────────────────────────────────
+    async clear() {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.tables.vtxos}`);
+        await this.db.run(`DELETE FROM ${this.tables.utxos}`);
+        await this.db.run(`DELETE FROM ${this.tables.transactions}`);
+        await this.db.run(`DELETE FROM ${this.tables.walletState}`);
+    }
+    // ── VTXO management ────────────────────────────────────────────────
+    async getVtxos(address) {
+        await this.ensureInit();
+        const rows = await this.db.all(`SELECT * FROM ${this.tables.vtxos} WHERE address = ?`, [address]);
+        return rows.map(vtxoRowToDomain);
+    }
+    async saveVtxos(address, vtxos) {
+        await this.ensureInit();
+        for (const vtxo of vtxos) {
+            const s = serializeVtxo(vtxo);
+            await this.db.run(`INSERT OR REPLACE INTO ${this.tables.vtxos}
+                    (txid, vout, value, address,
+                     tap_tree, forfeit_cb, forfeit_s, intent_cb, intent_s,
+                     status_json, virtual_status_json, created_at,
+                     is_unrolled, is_spent, spent_by, settled_by, ark_tx_id,
+                     extra_witness_json, assets_json)
+                 VALUES (?, ?, ?, ?,
+                         ?, ?, ?, ?, ?,
+                         ?, ?, ?,
+                         ?, ?, ?, ?, ?,
+                         ?, ?)`, [
+                s.txid,
+                s.vout,
+                s.value,
+                address,
+                s.tapTree,
+                s.forfeitTapLeafScript.cb,
+                s.forfeitTapLeafScript.s,
+                s.intentTapLeafScript.cb,
+                s.intentTapLeafScript.s,
+                JSON.stringify(s.status),
+                JSON.stringify(s.virtualStatus),
+                typeof s.createdAt === "string"
+                    ? s.createdAt
+                    : s.createdAt instanceof Date
+                        ? s.createdAt.toISOString()
+                        : new Date(s.createdAt).toISOString(),
+                s.isUnrolled ? 1 : 0,
+                s.isSpent === undefined ? null : s.isSpent ? 1 : 0,
+                s.spentBy ?? null,
+                s.settledBy ?? null,
+                s.arkTxId ?? null,
+                s.extraWitness ? JSON.stringify(s.extraWitness) : null,
+                s.assets ? JSON.stringify(s.assets) : null,
+            ]);
+        }
+    }
+    async deleteVtxos(address) {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.tables.vtxos} WHERE address = ?`, [address]);
+    }
+    // ── UTXO management ────────────────────────────────────────────────
+    async getUtxos(address) {
+        await this.ensureInit();
+        const rows = await this.db.all(`SELECT * FROM ${this.tables.utxos} WHERE address = ?`, [address]);
+        return rows.map(utxoRowToDomain);
+    }
+    async saveUtxos(address, utxos) {
+        await this.ensureInit();
+        for (const utxo of utxos) {
+            const s = serializeUtxo(utxo);
+            await this.db.run(`INSERT OR REPLACE INTO ${this.tables.utxos}
+                    (txid, vout, value, address,
+                     tap_tree, forfeit_cb, forfeit_s, intent_cb, intent_s,
+                     status_json, extra_witness_json)
+                 VALUES (?, ?, ?, ?,
+                         ?, ?, ?, ?, ?,
+                         ?, ?)`, [
+                s.txid,
+                s.vout,
+                s.value,
+                address,
+                s.tapTree,
+                s.forfeitTapLeafScript.cb,
+                s.forfeitTapLeafScript.s,
+                s.intentTapLeafScript.cb,
+                s.intentTapLeafScript.s,
+                JSON.stringify(s.status),
+                s.extraWitness ? JSON.stringify(s.extraWitness) : null,
+            ]);
+        }
+    }
+    async deleteUtxos(address) {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.tables.utxos} WHERE address = ?`, [address]);
+    }
+    // ── Transaction history ────────────────────────────────────────────
+    async getTransactionHistory(address) {
+        await this.ensureInit();
+        const rows = await this.db.all(`SELECT * FROM ${this.tables.transactions} WHERE address = ? ORDER BY created_at ASC`, [address]);
+        return rows.map(txRowToDomain);
+    }
+    async saveTransactions(address, txs) {
+        await this.ensureInit();
+        for (const tx of txs) {
+            await this.db.run(`INSERT OR REPLACE INTO ${this.tables.transactions}
+                    (address, boarding_txid, commitment_txid, ark_txid,
+                     type, amount, settled, created_at, assets_json)
+                 VALUES (?, ?, ?, ?,
+                         ?, ?, ?, ?, ?)`, [
+                address,
+                tx.key.boardingTxid,
+                tx.key.commitmentTxid,
+                tx.key.arkTxid,
+                tx.type,
+                tx.amount,
+                tx.settled ? 1 : 0,
+                tx.createdAt,
+                tx.assets ? JSON.stringify(tx.assets) : null,
+            ]);
+        }
+    }
+    async deleteTransactions(address) {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.tables.transactions} WHERE address = ?`, [address]);
+    }
+    // ── Wallet state ───────────────────────────────────────────────────
+    async getWalletState() {
+        await this.ensureInit();
+        const row = await this.db.get(`SELECT * FROM ${this.tables.walletState} WHERE key = ?`, ["state"]);
+        if (!row)
+            return null;
+        const state = {};
+        if (row.last_sync_time !== null && row.last_sync_time !== undefined) {
+            state.lastSyncTime = row.last_sync_time;
+        }
+        if (row.settings_json) {
+            state.settings = JSON.parse(row.settings_json);
+        }
+        return state;
+    }
+    async saveWalletState(state) {
+        await this.ensureInit();
+        await this.db.run(`INSERT OR REPLACE INTO ${this.tables.walletState}
+                (key, last_sync_time, settings_json)
+             VALUES (?, ?, ?)`, [
+            "state",
+            state.lastSyncTime ?? null,
+            state.settings ? JSON.stringify(state.settings) : null,
+        ]);
+    }
+}
+const SAFE_PREFIX = /^[a-zA-Z0-9_]+$/;
+function sanitizePrefix(prefix) {
+    if (!SAFE_PREFIX.test(prefix)) {
+        throw new Error(`Invalid table prefix "${prefix}": only letters, digits, and underscores are allowed`);
+    }
+    return prefix;
+}
+// ── Row → Domain converters ────────────────────────────────────────────
+function vtxoRowToDomain(row) {
+    const serialized = {
+        txid: row.txid,
+        vout: row.vout,
+        value: row.value,
+        tapTree: row.tap_tree,
+        forfeitTapLeafScript: {
+            cb: row.forfeit_cb,
+            s: row.forfeit_s,
+        },
+        intentTapLeafScript: {
+            cb: row.intent_cb,
+            s: row.intent_s,
+        },
+        status: JSON.parse(row.status_json),
+        virtualStatus: JSON.parse(row.virtual_status_json),
+        createdAt: new Date(row.created_at),
+        isUnrolled: row.is_unrolled === 1,
+        isSpent: row.is_spent === null ? undefined : row.is_spent === 1,
+        spentBy: row.spent_by ?? undefined,
+        settledBy: row.settled_by ?? undefined,
+        arkTxId: row.ark_tx_id ?? undefined,
+        extraWitness: row.extra_witness_json
+            ? JSON.parse(row.extra_witness_json)
+            : undefined,
+        assets: row.assets_json ? JSON.parse(row.assets_json) : undefined,
+    };
+    return deserializeVtxo(serialized);
+}
+function utxoRowToDomain(row) {
+    const serialized = {
+        txid: row.txid,
+        vout: row.vout,
+        value: row.value,
+        tapTree: row.tap_tree,
+        forfeitTapLeafScript: {
+            cb: row.forfeit_cb,
+            s: row.forfeit_s,
+        },
+        intentTapLeafScript: {
+            cb: row.intent_cb,
+            s: row.intent_s,
+        },
+        status: JSON.parse(row.status_json),
+        extraWitness: row.extra_witness_json
+            ? JSON.parse(row.extra_witness_json)
+            : undefined,
+    };
+    return deserializeUtxo(serialized);
+}
+function txRowToDomain(row) {
+    const tx = {
+        key: {
+            boardingTxid: row.boarding_txid,
+            commitmentTxid: row.commitment_txid,
+            arkTxid: row.ark_txid,
+        },
+        type: row.type,
+        amount: row.amount,
+        settled: row.settled === 1,
+        createdAt: row.created_at,
+    };
+    if (row.assets_json) {
+        tx.assets = JSON.parse(row.assets_json);
+    }
+    return tx;
+}

package/dist/esm/repositories/walletRepository.js

@@ -1,167 +1 @@
-import { hex } from "@scure/base";
-import { TaprootControlBlock } from "@scure/btc-signer";
-const getVtxosStorageKey = (address) => `vtxos:${address}`;
-const getUtxosStorageKey = (address) => `utxos:${address}`;
-const getTransactionsStorageKey = (address) => `tx:${address}`;
-const walletStateStorageKey = "wallet:state";
-// Utility functions for (de)serializing complex structures
-const toHex = (b) => (b ? hex.encode(b) : undefined);
-const fromHex = (h) => h ? hex.decode(h) : undefined;
-const serializeTapLeaf = ([cb, s]) => ({
-    cb: hex.encode(TaprootControlBlock.encode(cb)),
-    s: hex.encode(s),
-});
-const serializeVtxo = (v) => ({
-    ...v,
-    tapTree: toHex(v.tapTree),
-    forfeitTapLeafScript: serializeTapLeaf(v.forfeitTapLeafScript),
-    intentTapLeafScript: serializeTapLeaf(v.intentTapLeafScript),
-    extraWitness: v.extraWitness?.map(toHex),
-});
-const serializeUtxo = (u) => ({
-    ...u,
-    tapTree: toHex(u.tapTree),
-    forfeitTapLeafScript: serializeTapLeaf(u.forfeitTapLeafScript),
-    intentTapLeafScript: serializeTapLeaf(u.intentTapLeafScript),
-    extraWitness: u.extraWitness?.map(toHex),
-});
-const deserializeTapLeaf = (t) => {
-    const cb = TaprootControlBlock.decode(fromHex(t.cb));
-    const s = fromHex(t.s);
-    return [cb, s];
-};
-const deserializeVtxo = (o) => ({
-    ...o,
-    createdAt: new Date(o.createdAt),
-    tapTree: fromHex(o.tapTree),
-    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
-    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
-    extraWitness: o.extraWitness?.map(fromHex),
-});
-const deserializeUtxo = (o) => ({
-    ...o,
-    tapTree: fromHex(o.tapTree),
-    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
-    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
-    extraWitness: o.extraWitness?.map(fromHex),
-});
-export class WalletRepositoryImpl {
-    constructor(storage) {
-        this.storage = storage;
-    }
-    async getVtxos(address) {
-        const stored = await this.storage.getItem(getVtxosStorageKey(address));
-        if (!stored)
-            return [];
-        try {
-            const parsed = JSON.parse(stored);
-            return parsed.map(deserializeVtxo);
-        }
-        catch (error) {
-            console.error(`Failed to parse VTXOs for address ${address}:`, error);
-            return [];
-        }
-    }
-    async saveVtxos(address, vtxos) {
-        const storedVtxos = await this.getVtxos(address);
-        for (const vtxo of vtxos) {
-            const existing = storedVtxos.findIndex((v) => v.txid === vtxo.txid && v.vout === vtxo.vout);
-            if (existing !== -1) {
-                storedVtxos[existing] = vtxo;
-            }
-            else {
-                storedVtxos.push(vtxo);
-            }
-        }
-        await this.storage.setItem(getVtxosStorageKey(address), JSON.stringify(storedVtxos.map(serializeVtxo)));
-    }
-    async removeVtxo(address, vtxoId) {
-        const vtxos = await this.getVtxos(address);
-        const [txid, vout] = vtxoId.split(":");
-        const filtered = vtxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout, 10)));
-        await this.storage.setItem(getVtxosStorageKey(address), JSON.stringify(filtered.map(serializeVtxo)));
-    }
-    async clearVtxos(address) {
-        await this.storage.removeItem(getVtxosStorageKey(address));
-    }
-    async getUtxos(address) {
-        const stored = await this.storage.getItem(getUtxosStorageKey(address));
-        if (!stored)
-            return [];
-        try {
-            const parsed = JSON.parse(stored);
-            return parsed.map(deserializeUtxo);
-        }
-        catch (error) {
-            console.error(`Failed to parse UTXOs for address ${address}:`, error);
-            return [];
-        }
-    }
-    async saveUtxos(address, utxos) {
-        const storedUtxos = await this.getUtxos(address);
-        utxos.forEach((utxo) => {
-            const existing = storedUtxos.findIndex((u) => u.txid === utxo.txid && u.vout === utxo.vout);
-            if (existing !== -1) {
-                storedUtxos[existing] = utxo;
-            }
-            else {
-                storedUtxos.push(utxo);
-            }
-        });
-        await this.storage.setItem(getUtxosStorageKey(address), JSON.stringify(storedUtxos.map(serializeUtxo)));
-    }
-    async removeUtxo(address, utxoId) {
-        const utxos = await this.getUtxos(address);
-        const [txid, vout] = utxoId.split(":");
-        const filtered = utxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout, 10)));
-        await this.storage.setItem(getUtxosStorageKey(address), JSON.stringify(filtered.map(serializeUtxo)));
-    }
-    async clearUtxos(address) {
-        await this.storage.removeItem(getUtxosStorageKey(address));
-    }
-    async getTransactionHistory(address) {
-        const storageKey = getTransactionsStorageKey(address);
-        const stored = await this.storage.getItem(storageKey);
-        if (!stored)
-            return [];
-        try {
-            return JSON.parse(stored);
-        }
-        catch (error) {
-            console.error(`Failed to parse transactions for address ${address}:`, error);
-            return [];
-        }
-    }
-    async saveTransactions(address, txs) {
-        const storedTransactions = await this.getTransactionHistory(address);
-        for (const tx of txs) {
-            const existing = storedTransactions.findIndex((t) => t.key === tx.key);
-            if (existing !== -1) {
-                storedTransactions[existing] = tx;
-            }
-            else {
-                storedTransactions.push(tx);
-            }
-        }
-        await this.storage.setItem(getTransactionsStorageKey(address), JSON.stringify(storedTransactions));
-    }
-    async clearTransactions(address) {
-        await this.storage.removeItem(getTransactionsStorageKey(address));
-    }
-    async getWalletState() {
-        const stored = await this.storage.getItem(walletStateStorageKey);
-        if (!stored)
-            return null;
-        try {
-            const state = JSON.parse(stored);
-            return state;
-        }
-        catch (error) {
-            console.error("Failed to parse wallet state:", error);
-            return null;
-        }
-    }
-    async saveWalletState(state) {
-        await this.storage.setItem(walletStateStorageKey, JSON.stringify(state));
-    }
-}
+export {};