@totemsdk/omnia-host 0.9.0 → 0.11.0

package/dist/stores/operations.js

@@ -1,120 +1,133 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationStore = void 0;
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const node_crypto_1 = require("node:crypto");
+const sqlite_sync_1 = require("@totemsdk/storage/sqlite-sync");
+const PREFIX = 'omnia:operation:';
+const FORMAT_KEY = 'omnia:store:operation:format';
+const STORE_FORMAT = 1;
 /**
- * CAN-001: operation requests/results can carry `bigint` amounts (e.g. a
- * multi-hop route's hop amounts). `JSON.stringify` throws on bigint, so encode
- * with a reversible tag and decode it back — the journal never sees a raw
- * primitive it cannot persist.
+ * CAN-001: operation requests/results can carry `bigint` amounts. The storage
+ * codec tags bigints natively, so the record is persisted as-is. Legacy
+ * `omnia_operations` rows (JSON with `{$bigint}` tags) are migrated on open.
  */
-function bigintReplacer(_key, value) {
-    return typeof value === 'bigint' ? { $bigint: value.toString() } : value;
-}
-function bigintReviver(_key, value) {
-    if (value !== null &&
-        typeof value === 'object' &&
-        typeof value.$bigint === 'string' &&
-        Object.keys(value).length === 1) {
-        return BigInt(value.$bigint);
-    }
-    return value;
-}
-function encode(value) {
-    return value === undefined ? null : JSON.stringify(value, bigintReplacer);
-}
-function decode(value) {
-    return value === null ? undefined : JSON.parse(value, bigintReviver);
-}
-function toRecord(row) {
-    return {
-        operationId: row.operation_id,
-        status: row.status,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-        request: decode(row.request_json),
-        requestDigest: row.request_digest ?? undefined,
-        result: decode(row.result_json),
-        error: row.error ?? undefined,
-    };
+function decodeLegacy(value) {
+    if (value === null)
+        return undefined;
+    return JSON.parse(value, (_key, nested) => {
+        if (nested !== null &&
+            typeof nested === 'object' &&
+            typeof nested.$bigint === 'string' &&
+            Object.keys(nested).length === 1) {
+            return BigInt(nested.$bigint);
+        }
+        return nested;
+    });
 }
-/** Durable operation journal with atomic status transitions. */
+/** Durable operation journal with atomic status transitions, via storage SDK. */
 class OperationStore {
-    db;
+    kv;
     constructor(dbPath) {
-        this.db = new better_sqlite3_1.default(dbPath);
-        this.db.pragma('journal_mode = WAL');
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS omnia_operations (
-        operation_id TEXT PRIMARY KEY,
-        status TEXT NOT NULL,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        request_json TEXT,
-        request_digest TEXT,
-        result_json TEXT,
-        error TEXT
-      )
-    `);
-        const columns = this.db.prepare('PRAGMA table_info(omnia_operations)').all();
-        if (!columns.some((column) => column.name === 'request_digest')) {
-            this.db.exec('ALTER TABLE omnia_operations ADD COLUMN request_digest TEXT');
+        this.kv = new sqlite_sync_1.SyncSqliteStore(dbPath);
+        const version = this.kv.get(FORMAT_KEY);
+        if (version !== null && version !== STORE_FORMAT) {
+            this.kv.close();
+            throw new Error(`Unsupported OperationStore format ${version} (this build supports ${STORE_FORMAT}) — refusing to open`);
         }
+        if (version === null)
+            this.migrateLegacy();
+    }
+    migrateLegacy() {
+        // One-time migration from the pre-storage direct-SQLite table.
+        this.kv.migrateLegacyTable('omnia_operations', (row) => {
+            const request = decodeLegacy(row['request_json'] ?? null);
+            const result = decodeLegacy(row['result_json'] ?? null);
+            const digestValue = row['request_digest'] ? String(row['request_digest']) : undefined;
+            const error = row['error'] ? String(row['error']) : undefined;
+            const record = {
+                operationId: String(row['operation_id']),
+                status: row['status'] ?? 'unknown',
+                createdAt: Number(row['created_at']),
+                updatedAt: Number(row['updated_at']),
+                ...(request !== undefined ? { request } : {}),
+                ...(digestValue ? { requestDigest: digestValue } : {}),
+                ...(result !== undefined ? { result } : {}),
+                ...(error ? { error } : {}),
+            };
+            return { key: PREFIX + record.operationId, value: record };
+        });
+        this.kv.set(FORMAT_KEY, STORE_FORMAT);
     }
     get(operationId) {
-        const row = this.db.prepare('SELECT * FROM omnia_operations WHERE operation_id = ?').get(operationId);
-        return row ? toRecord(row) : undefined;
+        return this.kv.get(PREFIX + operationId) ?? undefined;
     }
     create(operationId, request, now = Date.now()) {
-        this.db.prepare(`
-      INSERT OR IGNORE INTO omnia_operations
-        (operation_id, status, created_at, updated_at, request_json, request_digest)
-      VALUES (?, 'pending', ?, ?, ?, ?)
-    `).run(operationId, now, now, encode(request), digest(request));
-        const record = this.get(operationId);
-        if (!record)
-            throw new Error(`Failed to create operation ${operationId}`);
-        return record;
+        return this.kv.transaction(() => {
+            const existing = this.get(operationId);
+            if (existing)
+                return existing;
+            const record = {
+                operationId,
+                status: 'pending',
+                createdAt: now,
+                updatedAt: now,
+                ...(request !== undefined ? { request } : {}),
+                requestDigest: digest(request),
+            };
+            this.kv.set(PREFIX + operationId, record);
+            return record;
+        });
     }
     verifyRequest(operationId, request) {
         const record = this.get(operationId);
         return !record?.requestDigest || record.requestDigest === digest(request);
     }
     transition(operationId, from, to, patch = {}, now = Date.now()) {
-        const result = this.db.prepare(`
-      UPDATE omnia_operations
-      SET status = ?, updated_at = ?, result_json = ?, error = ?
-      WHERE operation_id = ? AND status = ?
-    `).run(to, now, encode(patch.result), patch.error ?? null, operationId, from);
-        if (result.changes !== 1) {
-            const current = this.get(operationId);
-            if (!current)
+        return this.kv.transaction(() => {
+            const record = this.get(operationId);
+            if (!record)
                 throw new Error(`Unknown operation ${operationId}`);
-            throw new Error(`Operation ${operationId} expected status ${from} but is ${current.status}`);
-        }
-        return this.get(operationId);
+            if (record.status !== from) {
+                throw new Error(`Operation ${operationId} expected status ${from} but is ${record.status}`);
+            }
+            const next = {
+                ...record,
+                status: to,
+                updatedAt: now,
+                ...(patch.error !== undefined ? { error: patch.error } : {}),
+                ...(patch.result !== undefined ? { result: patch.result } : {}),
+            };
+            this.kv.set(PREFIX + operationId, next);
+            return next;
+        });
     }
     listByStatus(status) {
-        const rows = this.db.prepare('SELECT * FROM omnia_operations WHERE status = ? ORDER BY created_at').all(status);
-        return rows.map(toRecord);
+        return this.kv
+            .keys()
+            .filter((key) => key.startsWith(PREFIX))
+            .map((key) => this.kv.get(key))
+            .filter((record) => record !== null)
+            .filter((record) => record.status === status)
+            .sort((a, b) => a.createdAt - b.createdAt);
     }
     close() {
-        this.db.close();
+        this.kv.close();
     }
 }
 exports.OperationStore = OperationStore;
 function canonical(value) {
+    if (value === undefined)
+        return 'undefined';
     if (typeof value === 'bigint')
         return `{"$bigint":${JSON.stringify(value.toString())}}`;
     if (value === null || typeof value !== 'object')
-        return JSON.stringify(value);
+        return JSON.stringify(value) ?? 'null';
     if (Array.isArray(value))
         return `[${value.map(canonical).join(',')}]`;
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+    return `{${Object.keys(value)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+        .join(',')}}`;
 }
 function digest(value) {
     return (0, node_crypto_1.createHash)('sha256').update(canonical(value)).digest('hex');

package/dist/stores/sqlite-store.d.ts

@@ -1,10 +1,11 @@
 import { type OmniaChannel, type ChannelSigner } from '@totemsdk/omnia';
-/** SQLite-backed Map facade accepted by @totemsdk/omnia's ChannelStore type. */
+/**
+ * Synchronous Map facade accepted by @totemsdk/omnia's ChannelStore type,
+ * persisted through `@totemsdk/storage` (`SyncSqliteStore`, same codec/envelope
+ * as `SqliteStore`). Legacy `omnia_channels` tables are migrated on open.
+ */
 export declare class SqliteChannelStore extends Map<string, OmniaChannel> {
-    private readonly db;
-    private readonly readStatement;
-    private readonly writeStatement;
-    private readonly deleteStatement;
+    private readonly kv;
     /**
      * CAN-002: a recovered channel loses `localSigner` (it is not serializable),
      * so the router's `counterpartPkd()` cannot tell which party is local and
@@ -15,6 +16,8 @@ export declare class SqliteChannelStore extends Map<string, OmniaChannel> {
     /** Attach the host's signer so recovered channels carry it (CAN-002). */
     setLocalSigner(signer?: ChannelSigner): void;
     private rebind;
+    private channelKeys;
+    private idOf;
     get(channelId: string): OmniaChannel | undefined;
     set(channelId: string, channel: OmniaChannel): this;
     has(channelId: string): boolean;

package/dist/stores/sqlite-store.js

@@ -1,11 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqliteChannelStore = void 0;
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const sqlite_sync_1 = require("@totemsdk/storage/sqlite-sync");
 const omnia_1 = require("@totemsdk/omnia");
+const PREFIX = 'omnia:channel:';
+const FORMAT_KEY = 'omnia:store:channel:format';
+const STORE_FORMAT = 1;
 function iterator(values) {
     let index = 0;
     return {
@@ -22,12 +22,13 @@ function iterator(values) {
         },
     };
 }
-/** SQLite-backed Map facade accepted by @totemsdk/omnia's ChannelStore type. */
+/**
+ * Synchronous Map facade accepted by @totemsdk/omnia's ChannelStore type,
+ * persisted through `@totemsdk/storage` (`SyncSqliteStore`, same codec/envelope
+ * as `SqliteStore`). Legacy `omnia_channels` tables are migrated on open.
+ */
 class SqliteChannelStore extends Map {
-    db;
-    readStatement;
-    writeStatement;
-    deleteStatement;
+    kv;
     /**
      * CAN-002: a recovered channel loses `localSigner` (it is not serializable),
      * so the router's `counterpartPkd()` cannot tell which party is local and
@@ -36,24 +37,20 @@ class SqliteChannelStore extends Map {
     localSigner;
     constructor(dbPath) {
         super();
-        this.db = new better_sqlite3_1.default(dbPath);
-        this.db.pragma('journal_mode = WAL');
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS omnia_channels (
-        channel_id TEXT PRIMARY KEY,
-        channel_json TEXT NOT NULL,
-        updated_at INTEGER NOT NULL
-      )
-    `);
-        this.readStatement = this.db.prepare('SELECT channel_json FROM omnia_channels WHERE channel_id = ?');
-        this.writeStatement = this.db.prepare(`
-      INSERT INTO omnia_channels (channel_id, channel_json, updated_at)
-      VALUES (?, ?, ?)
-      ON CONFLICT(channel_id) DO UPDATE SET
-        channel_json = excluded.channel_json,
-        updated_at = excluded.updated_at
-    `);
-        this.deleteStatement = this.db.prepare('DELETE FROM omnia_channels WHERE channel_id = ?');
+        this.kv = new sqlite_sync_1.SyncSqliteStore(dbPath);
+        const version = this.kv.get(FORMAT_KEY);
+        if (version !== null && version !== STORE_FORMAT) {
+            this.kv.close();
+            throw new Error(`Unsupported SqliteChannelStore format ${version} (this build supports ${STORE_FORMAT}) — refusing to open`);
+        }
+        if (version === null) {
+            // One-time migration from the pre-storage direct-SQLite table.
+            this.kv.migrateLegacyTable('omnia_channels', (row) => ({
+                key: PREFIX + String(row['channel_id']),
+                value: String(row['channel_json']),
+            }));
+            this.kv.set(FORMAT_KEY, STORE_FORMAT);
+        }
     }
     /** Attach the host's signer so recovered channels carry it (CAN-002). */
     setLocalSigner(signer) {
@@ -62,36 +59,42 @@ class SqliteChannelStore extends Map {
     rebind(channel) {
         return this.localSigner ? { ...channel, localSigner: this.localSigner } : channel;
     }
+    channelKeys() {
+        return this.kv.keys().filter((key) => key.startsWith(PREFIX));
+    }
+    idOf(key) {
+        return key.slice(PREFIX.length);
+    }
     get(channelId) {
-        const row = this.readStatement.get(channelId);
-        return row ? this.rebind((0, omnia_1.recoverChannel)(row.channel_json)) : undefined;
+        const snapshot = this.kv.get(PREFIX + channelId);
+        return snapshot ? this.rebind((0, omnia_1.recoverChannel)(snapshot)) : undefined;
     }
     set(channelId, channel) {
-        this.writeStatement.run(channelId, (0, omnia_1.serializeChannelSnapshot)(channel), Date.now());
+        this.kv.set(PREFIX + channelId, (0, omnia_1.serializeChannelSnapshot)(channel));
         return this;
     }
     has(channelId) {
-        return this.readStatement.get(channelId) !== undefined;
+        return this.kv.has(PREFIX + channelId);
     }
     delete(channelId) {
-        return this.deleteStatement.run(channelId).changes > 0;
+        return this.kv.remove(PREFIX + channelId);
     }
     clear() {
-        this.db.exec('DELETE FROM omnia_channels');
+        for (const key of this.channelKeys())
+            this.kv.remove(key);
     }
     get size() {
-        const row = this.db.prepare('SELECT COUNT(*) AS count FROM omnia_channels').get();
-        return row.count;
+        return this.channelKeys().length;
     }
     entries() {
-        const rows = this.db.prepare('SELECT channel_id, channel_json FROM omnia_channels ORDER BY channel_id').iterate();
-        return iterator(Array.from(rows, (row) => [
-            row.channel_id,
-            this.rebind((0, omnia_1.recoverChannel)(row.channel_json)),
-        ]));
+        const rows = this.channelKeys().map((key) => {
+            const snapshot = this.kv.get(key);
+            return [this.idOf(key), this.rebind((0, omnia_1.recoverChannel)(snapshot))];
+        });
+        return iterator(rows);
     }
     keys() {
-        return iterator(Array.from(this.entries(), ([channelId]) => channelId));
+        return iterator(this.channelKeys().map((key) => this.idOf(key)));
     }
     values() {
         return iterator(Array.from(this.entries(), ([, channel]) => channel));
@@ -104,7 +107,7 @@ class SqliteChannelStore extends Map {
             callbackfn(value, key, this);
     }
     close() {
-        this.db.close();
+        this.kv.close();
     }
 }
 exports.SqliteChannelStore = SqliteChannelStore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/omnia-host",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Durable Omnia node daemon for channel lifecycle, routing, and control APIs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,27 +17,29 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "NOTICE"
   ],
   "dependencies": {
-    "better-sqlite3": "^12.2.0",
     "ws": "^8.21.1",
-    "@totemsdk/chain-provider": "^0.3.0",
     "@totemsdk/core": "^1.4.0",
-    "@totemsdk/identity": "^1.0.1",
-    "@totemsdk/omnia": "^2.2.0",
-    "@totemsdk/manifest": "^2.0.0",
-    "@totemsdk/omnia-factory": "^0.6.0",
-    "@totemsdk/omnia-router": "^0.3.0",
-    "@totemsdk/omnia-splice": "^0.3.0",
-    "@totemsdk/omnia-vtxo": "^0.6.0",
-    "@totemsdk/storage": "^0.1.0",
+    "@totemsdk/identity": "^1.0.2",
+    "@totemsdk/chain-provider": "^0.3.0",
+    "@totemsdk/liquidity-bond": "^0.3.1",
+    "@totemsdk/manifest": "^2.0.1",
     "@totemsdk/minima-rpc": "^0.4.0",
+    "@totemsdk/omnia": "^2.3.1",
+    "@totemsdk/omnia-factory": "^0.7.0",
+    "@totemsdk/omnia-router": "^0.4.0",
+    "@totemsdk/omnia-pool": "^0.5.3",
+    "@totemsdk/omnia-splice": "^0.3.0",
+    "@totemsdk/p2p-hub": "^0.1.0",
+    "@totemsdk/omnia-vtxo": "^0.6.1",
+    "@totemsdk/storage": "^0.2.0",
     "@totemsdk/wots-lease": "^1.0.1"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^20.19.43",
     "@types/ws": "^8.5.0",
     "jest": "^30.4.2",
@@ -51,7 +53,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
+  "license": "Apache-2.0",
   "author": "Totem SDK",
   "homepage": "https://docs.totem.ing",
   "repository": {