@1sat/wallet-toolbox 0.0.6 → 0.0.7

package/dist/sync/IndexedDbSyncQueue.js

@@ -0,0 +1,355 @@
+const QUEUE_STORE = "queue";
+const STATE_STORE = "state";
+const STATE_KEY = "syncState";
+const DB_VERSION = 1;
+/**
+ * IndexedDB implementation of SyncQueueStorage for browser environments.
+ */
+export class IndexedDbSyncQueue {
+    dbName;
+    db = null;
+    dbPromise = null;
+    /**
+     * Create a new IndexedDB sync queue.
+     * @param accountId - Unique identifier for the account (e.g., address, pubkey hash)
+     */
+    constructor(accountId) {
+        this.dbName = `sync-queue-${accountId}`;
+    }
+    async getDb() {
+        if (this.db)
+            return this.db;
+        if (this.dbPromise)
+            return this.dbPromise;
+        this.dbPromise = new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, DB_VERSION);
+            request.onerror = () => reject(request.error);
+            request.onblocked = () => {
+                reject(new Error("Database blocked - close other tabs"));
+            };
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve(this.db);
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                // Queue store with indexes
+                if (!db.objectStoreNames.contains(QUEUE_STORE)) {
+                    const queueStore = db.createObjectStore(QUEUE_STORE, {
+                        keyPath: "id",
+                    });
+                    queueStore.createIndex("status", "status", { unique: false });
+                    queueStore.createIndex("outpoint", "outpoint", { unique: false });
+                }
+                // State store (simple key-value)
+                if (!db.objectStoreNames.contains(STATE_STORE)) {
+                    db.createObjectStore(STATE_STORE, { keyPath: "key" });
+                }
+            };
+        });
+        return this.dbPromise;
+    }
+    async enqueue(items) {
+        if (items.length === 0)
+            return;
+        const db = await this.getDb();
+        const now = Date.now();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(QUEUE_STORE, "readwrite");
+            const store = tx.objectStore(QUEUE_STORE);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+            for (const item of items) {
+                const id = `${item.outpoint}:${item.score}`;
+                // Check if item already exists
+                const getRequest = store.get(id);
+                getRequest.onsuccess = () => {
+                    const existing = getRequest.result;
+                    // Skip if already done
+                    if (existing?.status === "done") {
+                        return;
+                    }
+                    const queueItem = {
+                        id,
+                        outpoint: item.outpoint,
+                        score: item.score,
+                        spendTxid: item.spendTxid,
+                        status: "pending",
+                        attempts: existing?.attempts ?? 0,
+                        createdAt: existing?.createdAt ?? now,
+                        updatedAt: now,
+                    };
+                    store.put(queueItem);
+                };
+            }
+        });
+    }
+    async claim(count = 1) {
+        const db = await this.getDb();
+        const now = Date.now();
+        // Step 1: Find up to `count` pending items as seeds
+        const seedItems = await new Promise((resolve, reject) => {
+            const tx = db.transaction(QUEUE_STORE, "readonly");
+            const store = tx.objectStore(QUEUE_STORE);
+            const index = store.index("status");
+            const seeds = [];
+            const request = index.openCursor(IDBKeyRange.only("pending"));
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor && seeds.length < count) {
+                    seeds.push(cursor.value);
+                    cursor.continue();
+                }
+            };
+            tx.oncomplete = () => resolve(seeds);
+            tx.onerror = () => reject(tx.error);
+        });
+        if (seedItems.length === 0) {
+            return new Map();
+        }
+        // Step 2: Get unique txids from seeds
+        const txids = new Set();
+        for (const item of seedItems) {
+            txids.add(item.outpoint.substring(0, 64));
+        }
+        // Step 3: For each txid, get ALL pending items (not just seeds)
+        const byTxid = new Map();
+        for (const txid of txids) {
+            const items = await this.getPendingByTxid(txid);
+            if (items.length > 0) {
+                byTxid.set(txid, items);
+            }
+        }
+        // Step 4: Mark all gathered items as processing
+        const allItems = Array.from(byTxid.values()).flat();
+        await this.markProcessing(allItems, now);
+        return byTxid;
+    }
+    async getPendingByTxid(txid) {
+        const db = await this.getDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(QUEUE_STORE, "readonly");
+            const store = tx.objectStore(QUEUE_STORE);
+            const index = store.index("outpoint");
+            const results = [];
+            const request = index.openCursor();
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    const item = cursor.value;
+                    if (item.outpoint.startsWith(txid) && item.status === "pending") {
+                        results.push(item);
+                    }
+                    cursor.continue();
+                }
+            };
+            tx.oncomplete = () => resolve(results);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async markProcessing(items, now) {
+        if (items.length === 0)
+            return;
+        const db = await this.getDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(QUEUE_STORE, "readwrite");
+            const store = tx.objectStore(QUEUE_STORE);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+            for (const item of items) {
+                item.status = "processing";
+                item.attempts += 1;
+                item.updatedAt = now;
+                store.put(item);
+            }
+        });
+    }
+    async complete(id) {
+        return this.completeMany([id]);
+    }
+    async completeMany(ids) {
+        if (ids.length === 0)
+            return;
+        const db = await this.getDb();
+        const now = Date.now();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(QUEUE_STORE, "readwrite");
+            const store = tx.objectStore(QUEUE_STORE);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+            for (const id of ids) {
+                const request = store.get(id);
+                request.onsuccess = () => {
+                    const item = request.result;
+                    if (item) {
+                        item.status = "done";
+                        item.updatedAt = now;
+                        store.put(item);
+                    }
+                };
+            }
+        });
+    }
+    async fail(id, error) {
+        const db = await this.getDb();
+        const now = Date.now();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(QUEUE_STORE, "readwrite");
+            const store = tx.objectStore(QUEUE_STORE);
+            const request = store.get(id);
+            request.onsuccess = () => {
+                const item = request.result;
+                if (item) {
+                    item.status = "failed";
+                    item.lastError = error;
+                    item.updatedAt = now;
+                    store.put(item);
+                }
+            };
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async getByTxid(txid) {
+        const db = await this.getDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(QUEUE_STORE, "readonly");
+            const store = tx.objectStore(QUEUE_STORE);
+            const index = store.index("outpoint");
+            const results = [];
+            // Use a cursor to find all outpoints starting with this txid
+            const request = index.openCursor();
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    const item = cursor.value;
+                    if (item.outpoint.startsWith(txid)) {
+                        results.push(item);
+                    }
+                    cursor.continue();
+                }
+            };
+            tx.oncomplete = () => resolve(results);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async getByStatus(status, limit = 100) {
+        const db = await this.getDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(QUEUE_STORE, "readonly");
+            const store = tx.objectStore(QUEUE_STORE);
+            const index = store.index("status");
+            const results = [];
+            const request = index.openCursor(IDBKeyRange.only(status));
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor && results.length < limit) {
+                    results.push(cursor.value);
+                    cursor.continue();
+                }
+            };
+            tx.oncomplete = () => resolve(results);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async getStats() {
+        const db = await this.getDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(QUEUE_STORE, "readonly");
+            const store = tx.objectStore(QUEUE_STORE);
+            const request = store.openCursor();
+            const txidsByStatus = {
+                pending: new Set(),
+                processing: new Set(),
+                done: new Set(),
+                failed: new Set(),
+            };
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    const item = cursor.value;
+                    const txid = item.outpoint.substring(0, 64);
+                    txidsByStatus[item.status]?.add(txid);
+                    cursor.continue();
+                }
+                else {
+                    resolve({
+                        pending: txidsByStatus.pending.size,
+                        processing: txidsByStatus.processing.size,
+                        done: txidsByStatus.done.size,
+                        failed: txidsByStatus.failed.size,
+                    });
+                }
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async getState() {
+        const db = await this.getDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STATE_STORE, "readonly");
+            const store = tx.objectStore(STATE_STORE);
+            const request = store.get(STATE_KEY);
+            request.onsuccess = () => {
+                const result = request.result;
+                resolve(result?.value ?? { lastQueuedScore: 0 });
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async setState(state) {
+        const db = await this.getDb();
+        const current = await this.getState();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STATE_STORE, "readwrite");
+            const store = tx.objectStore(STATE_STORE);
+            store.put({
+                key: STATE_KEY,
+                value: { ...current, ...state },
+            });
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async resetProcessing() {
+        const db = await this.getDb();
+        const now = Date.now();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(QUEUE_STORE, "readwrite");
+            const store = tx.objectStore(QUEUE_STORE);
+            const index = store.index("status");
+            let count = 0;
+            const request = index.openCursor(IDBKeyRange.only("processing"));
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    const item = cursor.value;
+                    item.status = "pending";
+                    item.updatedAt = now;
+                    cursor.update(item);
+                    count++;
+                    cursor.continue();
+                }
+            };
+            tx.oncomplete = () => resolve(count);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async clear() {
+        const db = await this.getDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction([QUEUE_STORE, STATE_STORE], "readwrite");
+            tx.objectStore(QUEUE_STORE).clear();
+            tx.objectStore(STATE_STORE).clear();
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            this.dbPromise = null;
+        }
+    }
+}

package/dist/sync/SqliteSyncQueue.js

@@ -0,0 +1,197 @@
+/**
+ * SQLite implementation of SyncQueueStorage for Node/Bun environments.
+ *
+ * Works with both `better-sqlite3` (Node) and `bun:sqlite` (Bun).
+ */
+export class SqliteSyncQueue {
+    db;
+    /**
+     * Create a new SQLite sync queue.
+     * @param db - SQLite database instance (from better-sqlite3 or bun:sqlite)
+     */
+    constructor(db) {
+        this.db = db;
+        this.initialize();
+    }
+    /**
+     * Create and open a SQLite database for an account.
+     * Helper for common use case.
+     *
+     * @param accountId - Unique identifier for the account (e.g., address, pubkey hash)
+     * @param dataDir - Directory for database files
+     * @param Database - SQLite Database constructor (e.g., from better-sqlite3 or bun:sqlite)
+     */
+    static create(accountId, dataDir, 
+    // biome-ignore lint/suspicious/noExplicitAny: accepts any SQLite constructor
+    Database) {
+        const dbPath = `${dataDir}/sync-queue-${accountId}.db`;
+        const db = new Database(dbPath);
+        return new SqliteSyncQueue(db);
+    }
+    initialize() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS queue (
+        id TEXT PRIMARY KEY,
+        outpoint TEXT NOT NULL,
+        score INTEGER NOT NULL,
+        spend_txid TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        attempts INTEGER NOT NULL DEFAULT 0,
+        last_error TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_queue_status ON queue(status);
+      CREATE INDEX IF NOT EXISTS idx_queue_outpoint ON queue(outpoint);
+
+      CREATE TABLE IF NOT EXISTS state (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+    }
+    async enqueue(items) {
+        if (items.length === 0)
+            return;
+        const now = Date.now();
+        const checkStmt = this.db.prepare("SELECT status FROM queue WHERE id = ?");
+        const insertStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO queue (id, outpoint, score, spend_txid, status, attempts, created_at, updated_at)
+      VALUES (?, ?, ?, ?, 'pending', COALESCE((SELECT attempts FROM queue WHERE id = ?), 0), COALESCE((SELECT created_at FROM queue WHERE id = ?), ?), ?)
+    `);
+        for (const item of items) {
+            const id = `${item.outpoint}:${item.score}`;
+            // Skip if already done
+            const existing = checkStmt.get(id);
+            if (existing?.status === "done") {
+                continue;
+            }
+            insertStmt.run(id, item.outpoint, item.score, item.spendTxid ?? null, id, id, now, now);
+        }
+    }
+    async claim(count = 1) {
+        const now = Date.now();
+        // Step 1: Get up to `count` pending items as seeds
+        const seedRows = this.db
+            .prepare("SELECT * FROM queue WHERE status = 'pending' LIMIT ?")
+            .all(count);
+        if (seedRows.length === 0)
+            return new Map();
+        // Step 2: Get unique txids from seeds
+        const txids = new Set();
+        for (const row of seedRows) {
+            txids.add(row.outpoint.substring(0, 64));
+        }
+        // Step 3: For each txid, get ALL pending items
+        const byTxid = new Map();
+        const allIds = [];
+        for (const txid of txids) {
+            const rows = this.db
+                .prepare("SELECT * FROM queue WHERE outpoint LIKE ? AND status = 'pending'")
+                .all(`${txid}%`);
+            if (rows.length > 0) {
+                const items = rows.map((row) => this.rowToItem(row, "processing", now));
+                byTxid.set(txid, items);
+                allIds.push(...rows.map((r) => r.id));
+            }
+        }
+        // Step 4: Mark all gathered items as processing
+        if (allIds.length > 0) {
+            const placeholders = allIds.map(() => "?").join(",");
+            this.db
+                .prepare(`UPDATE queue SET status = 'processing', attempts = attempts + 1, updated_at = ?
+           WHERE id IN (${placeholders})`)
+                .run(now, ...allIds);
+        }
+        return byTxid;
+    }
+    async complete(id) {
+        return this.completeMany([id]);
+    }
+    async completeMany(ids) {
+        if (ids.length === 0)
+            return;
+        const now = Date.now();
+        const placeholders = ids.map(() => "?").join(",");
+        this.db
+            .prepare(`UPDATE queue SET status = 'done', updated_at = ? WHERE id IN (${placeholders})`)
+            .run(now, ...ids);
+    }
+    async fail(id, error) {
+        const now = Date.now();
+        this.db
+            .prepare("UPDATE queue SET status = 'failed', last_error = ?, updated_at = ? WHERE id = ?")
+            .run(error, now, id);
+    }
+    async getByTxid(txid) {
+        const rows = this.db
+            .prepare("SELECT * FROM queue WHERE outpoint LIKE ?")
+            .all(`${txid}%`);
+        return rows.map((row) => this.rowToItem(row));
+    }
+    async getByStatus(status, limit = 100) {
+        const rows = this.db
+            .prepare("SELECT * FROM queue WHERE status = ? LIMIT ?")
+            .all(status, limit);
+        return rows.map((row) => this.rowToItem(row));
+    }
+    async getStats() {
+        const row = this.db
+            .prepare(`SELECT
+          COUNT(DISTINCT CASE WHEN status = 'pending' THEN substr(outpoint, 1, 64) END) as pending,
+          COUNT(DISTINCT CASE WHEN status = 'processing' THEN substr(outpoint, 1, 64) END) as processing,
+          COUNT(DISTINCT CASE WHEN status = 'done' THEN substr(outpoint, 1, 64) END) as done,
+          COUNT(DISTINCT CASE WHEN status = 'failed' THEN substr(outpoint, 1, 64) END) as failed
+        FROM queue`)
+            .get();
+        return {
+            pending: row.pending ?? 0,
+            processing: row.processing ?? 0,
+            done: row.done ?? 0,
+            failed: row.failed ?? 0,
+        };
+    }
+    async getState() {
+        const row = this.db
+            .prepare("SELECT value FROM state WHERE key = 'syncState'")
+            .get();
+        if (!row) {
+            return { lastQueuedScore: 0 };
+        }
+        return JSON.parse(row.value);
+    }
+    async setState(state) {
+        const current = await this.getState();
+        const updated = { ...current, ...state };
+        this.db
+            .prepare("INSERT OR REPLACE INTO state (key, value) VALUES ('syncState', ?)")
+            .run(JSON.stringify(updated));
+    }
+    async resetProcessing() {
+        const now = Date.now();
+        const result = this.db
+            .prepare("UPDATE queue SET status = 'pending', updated_at = ? WHERE status = 'processing'")
+            .run(now);
+        return result.changes;
+    }
+    async clear() {
+        this.db.exec("DELETE FROM queue; DELETE FROM state;");
+    }
+    async close() {
+        this.db.close();
+    }
+    rowToItem(row, statusOverride, updatedAtOverride) {
+        return {
+            id: row.id,
+            outpoint: row.outpoint,
+            score: row.score,
+            spendTxid: row.spend_txid ?? undefined,
+            status: statusOverride ?? row.status,
+            attempts: statusOverride ? row.attempts + 1 : row.attempts,
+            lastError: row.last_error ?? undefined,
+            createdAt: row.created_at,
+            updatedAt: updatedAtOverride ?? row.updated_at,
+        };
+    }
+}

package/dist/sync/index.js

@@ -0,0 +1,3 @@
+export * from "./types";
+export { IndexedDbSyncQueue } from "./IndexedDbSyncQueue";
+export { SqliteSyncQueue } from "./SqliteSyncQueue";

package/dist/sync/types.js

@@ -0,0 +1,4 @@
+/**
+ * Sync queue types for background transaction processing.
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1sat/wallet-toolbox",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "BSV wallet library extending @bsv/wallet-toolbox with 1Sat Ordinals protocol support",
   "author": "1Sat Team",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target browser --define 'process.env={}' --define 'global=globalThis' --sourcemap=inline && tsc --emitDeclarationOnly",
+    "build": "tsc",
     "dev": "tsc --watch",
     "lint": "biome check src",
     "lint:fix": "biome check --write src",
@@ -37,13 +37,13 @@
     "tester": "bun run build && bun run tester:build && bun ./tester/server.ts"
   },
   "dependencies": {
-    "@bopen-io/ts-templates": "^1.1.0",
-    "@bsv/sdk": "1.9.24",
-    "@bsv/wallet-toolbox": "^1.7.14",
+    "@bopen-io/templates": "^1.1.2",
+    "@bsv/sdk": "^1.9.29",
     "buffer": "^6.0.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
+    "@bsv/wallet-toolbox": "^1.7.18",
     "@types/bun": "^1.3.4",
     "typescript": "^5.9.3"
   }