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

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

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteContractRepository = void 0;
+/**
+ * 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.
+ */
+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);
+        }
+    }
+}
+exports.SQLiteContractRepository = SQLiteContractRepository;
+// ── 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/cjs/repositories/sqlite/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteContractRepository = exports.SQLiteWalletRepository = void 0;
+var walletRepository_1 = require("./walletRepository");
+Object.defineProperty(exports, "SQLiteWalletRepository", { enumerable: true, get: function () { return walletRepository_1.SQLiteWalletRepository; } });
+var contractRepository_1 = require("./contractRepository");
+Object.defineProperty(exports, "SQLiteContractRepository", { enumerable: true, get: function () { return contractRepository_1.SQLiteContractRepository; } });

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteWalletRepository = void 0;
+const serialization_1 = require("../serialization");
+/**
+ * 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.
+ */
+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 = (0, serialization_1.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 = (0, serialization_1.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,
+        ]);
+    }
+}
+exports.SQLiteWalletRepository = SQLiteWalletRepository;
+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 (0, serialization_1.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 (0, serialization_1.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/cjs/wallet/serviceWorker/wallet.js

@@ -169,12 +169,20 @@ class ServiceWorkerReadonlyWallet {
     // send a message and wait for a response
     async sendMessage(request) {
         return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                navigator.serviceWorker.removeEventListener("message", messageHandler);
+            };
+            const timeoutId = setTimeout(() => {
+                cleanup();
+                reject(new Error(`Service worker message timed out (${request.type})`));
+            }, 30000);
             const messageHandler = (event) => {
                 const response = event.data;
                 if (request.id !== response.id) {
                     return;
                 }
-                navigator.serviceWorker.removeEventListener("message", messageHandler);
+                cleanup();
                 if (response.error) {
                     reject(response.error);
                 }

package/dist/cjs/wallet/vtxo-manager.js

@@ -93,6 +93,13 @@ function isVtxoExpiringSoon(vtxo, thresholdMs // in milliseconds
     const { batchExpiry } = vtxo.virtualStatus;
     if (!batchExpiry)
         return false; // it doesn't expire
+    // we use this as a workaround to avoid issue on regtest where expiry date is
+    // expressed in blockheight instead of timestamp. If expiry, as Date, is before 2025,
+    // then we admit it's too small to be a timestamp
+    // TODO: API should return the expiry unit
+    const expireAt = new Date(batchExpiry);
+    if (expireAt.getFullYear() < 2025)
+        return false;
     const now = Date.now();
     if (batchExpiry <= now)
         return false; // already expired

package/dist/cjs/worker/messageBus.js

@@ -107,8 +107,19 @@ class MessageBus {
         }
     }
     async waitForInit(config) {
-        if (this.initialized)
-            return;
+        if (this.initialized) {
+            // Stop existing handlers before re-initializing.
+            // This handles the case where CLEAR was called, which nullifies
+            // handler state (readonlyWallet, etc.) without resetting the
+            // initialized flag. Without this, handlers never get start()
+            // called again and all messages fail with "not initialized".
+            //
+            // Clear the flag first so onMessage() rejects incoming messages
+            // during the stop/start window instead of routing them to
+            // half-reset handlers. Restored to true after start() completes.
+            this.initialized = false;
+            await Promise.all(Array.from(this.handlers.values()).map((h) => h.stop().catch(() => { })));
+        }
         const services = await this.buildServicesFn(config);
         // Start all handlers
         for (const updater of this.handlers.values()) {
@@ -168,6 +179,15 @@ class MessageBus {
         if (!this.initialized) {
             if (this.debug)
                 console.warn("Event received before initialization, dropping", event.data);
+            // Send error response so the caller's promise rejects instead of
+            // hanging forever. This happens when the browser kills and restarts
+            // the service worker — the new instance has initialized=false and
+            // messages arrive before INITIALIZE_MESSAGE_BUS is re-sent.
+            event.source?.postMessage({
+                id,
+                tag: tag ?? "unknown",
+                error: new Error("MessageBus not initialized"),
+            });
             return;
         }
         if (!id || !tag) {