@totemsdk/omnia-host 0.10.0 → 0.12.0

package/dist/stores/persistent-map.d.ts

@@ -0,0 +1,31 @@
+import { SyncSqliteStore } from '@totemsdk/storage/sqlite-sync';
+/**
+ * Durable Map facade for host state (factories, virtual channels, splices,
+ * VTXOs, pools). Backed by `@totemsdk/storage/sqlite-sync` (same `totemsdk_kv`
+ * table + versioned codec as the channel/operation stores).
+ *
+ * Values are plain objects/arrays/bigints/Uint8Arrays. Runtime-only handles
+ * (`localSigner`, signer/lease/swarm objects) are stripped; Map/Set/Date are
+ * explicitly tagged so they round-trip. A function anywhere else is dropped
+ * rather than persisted (never serialise authority material by accident).
+ */
+export declare const HOST_STATE_FORMAT_KEY = "omnia:store:host-state:format";
+export declare const HOST_STATE_FORMAT = 1;
+export declare class PersistentMap<V> extends Map<string, V> {
+    private readonly kv;
+    private readonly namespace;
+    constructor(kv: SyncSqliteStore, namespace: string);
+    private key;
+    private keysInNamespace;
+    get(id: string): V | undefined;
+    set(id: string, value: V): this;
+    has(id: string): boolean;
+    delete(id: string): boolean;
+    clear(): void;
+    get size(): number;
+    keys(): MapIterator<string>;
+    values(): MapIterator<V>;
+    entries(): MapIterator<[string, V]>;
+    [Symbol.iterator](): MapIterator<[string, V]>;
+    forEach(callbackfn: (value: V, key: string, map: Map<string, V>) => void): void;
+}

package/dist/stores/persistent-map.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistentMap = exports.HOST_STATE_FORMAT = exports.HOST_STATE_FORMAT_KEY = void 0;
+/**
+ * Durable Map facade for host state (factories, virtual channels, splices,
+ * VTXOs, pools). Backed by `@totemsdk/storage/sqlite-sync` (same `totemsdk_kv`
+ * table + versioned codec as the channel/operation stores).
+ *
+ * Values are plain objects/arrays/bigints/Uint8Arrays. Runtime-only handles
+ * (`localSigner`, signer/lease/swarm objects) are stripped; Map/Set/Date are
+ * explicitly tagged so they round-trip. A function anywhere else is dropped
+ * rather than persisted (never serialise authority material by accident).
+ */
+exports.HOST_STATE_FORMAT_KEY = 'omnia:store:host-state:format';
+exports.HOST_STATE_FORMAT = 1;
+const EPHEMERAL_KEYS = new Set([
+    'localSigner',
+    'signer',
+    'leaseProvider',
+    'signerPort',
+    'swarm',
+    'routing',
+]);
+function encode(value, seen = new WeakSet()) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'bigint')
+        return value;
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'function')
+        return null;
+    if (value instanceof Uint8Array)
+        return value;
+    if (value instanceof Date)
+        return { $date: value.toISOString() };
+    if (Array.isArray(value)) {
+        return value.map((item) => encode(item, seen));
+    }
+    if (value instanceof Map) {
+        const entries = [];
+        for (const [key, item] of value.entries())
+            entries.push([String(key), encode(item, seen)]);
+        return { $map: entries };
+    }
+    if (value instanceof Set) {
+        return { $set: Array.from(value.values(), (item) => encode(item, seen)) };
+    }
+    if (typeof value === 'object') {
+        if (seen.has(value))
+            throw new Error('cannot persist cyclic host state');
+        seen.add(value);
+        const out = {};
+        for (const [key, item] of Object.entries(value)) {
+            if (EPHEMERAL_KEYS.has(key) || item === undefined || typeof item === 'function')
+                continue;
+            out[key] = encode(item, seen);
+        }
+        seen.delete(value);
+        return out;
+    }
+    return null;
+}
+function decode(value) {
+    if (value === null)
+        return null;
+    if (typeof value === 'bigint' ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (value instanceof Uint8Array)
+        return value;
+    if (Array.isArray(value))
+        return value.map(decode);
+    if (typeof value === 'object') {
+        const record = value;
+        if (Array.isArray(record['$map'])) {
+            return new Map(record['$map'].map(([key, item]) => [key, decode(item)]));
+        }
+        if (Array.isArray(record['$set'])) {
+            return new Set(record['$set'].map(decode));
+        }
+        if (typeof record['$date'] === 'string')
+            return new Date(record['$date']);
+        const out = {};
+        for (const [key, item] of Object.entries(record))
+            out[key] = decode(item);
+        return out;
+    }
+    return value;
+}
+function iterator(values) {
+    let index = 0;
+    return {
+        next() {
+            if (index >= values.length)
+                return { done: true, value: undefined };
+            return { done: false, value: values[index++] };
+        },
+        [Symbol.iterator]() {
+            return this;
+        },
+        [Symbol.dispose]() {
+            index = values.length;
+        },
+    };
+}
+class PersistentMap extends Map {
+    kv;
+    namespace;
+    constructor(kv, namespace) {
+        super();
+        this.kv = kv;
+        this.namespace = namespace;
+        const format = kv.get(exports.HOST_STATE_FORMAT_KEY);
+        if (format !== null && format !== exports.HOST_STATE_FORMAT) {
+            throw new Error(`Unsupported omnia-host state format ${format} (this build supports ${exports.HOST_STATE_FORMAT}) — refusing to open`);
+        }
+        if (format === null)
+            kv.set(exports.HOST_STATE_FORMAT_KEY, exports.HOST_STATE_FORMAT);
+    }
+    key(id) {
+        return this.namespace + id;
+    }
+    keysInNamespace() {
+        return this.kv.keys().filter((key) => key.startsWith(this.namespace));
+    }
+    get(id) {
+        const raw = this.kv.get(this.key(id));
+        return raw === null ? undefined : decode(raw);
+    }
+    set(id, value) {
+        this.kv.set(this.key(id), encode(value));
+        return this;
+    }
+    has(id) {
+        return this.kv.has(this.key(id));
+    }
+    delete(id) {
+        return this.kv.remove(this.key(id));
+    }
+    clear() {
+        for (const key of this.keysInNamespace())
+            this.kv.remove(key);
+    }
+    get size() {
+        return this.keysInNamespace().length;
+    }
+    keys() {
+        return iterator(this.keysInNamespace().map((key) => key.slice(this.namespace.length)));
+    }
+    values() {
+        return iterator(Array.from(this.entries(), ([, value]) => value));
+    }
+    entries() {
+        return iterator(this.keysInNamespace().map((key) => [
+            key.slice(this.namespace.length),
+            decode(this.kv.get(key)),
+        ]));
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(callbackfn) {
+        for (const [key, value] of this.entries())
+            callbackfn(value, key, this);
+    }
+}
+exports.PersistentMap = PersistentMap;

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.10.0",
+  "version": "0.12.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.2",
-    "@totemsdk/manifest": "^2.0.1",
-    "@totemsdk/omnia": "^2.3.0",
+    "@totemsdk/liquidity-bond": "^0.3.1",
+    "@totemsdk/manifest": "^2.0.2",
+    "@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-splice": "^0.3.0",
-    "@totemsdk/storage": "^0.1.0",
+    "@totemsdk/omnia-pool": "^0.5.3",
+    "@totemsdk/p2p-hub": "^0.1.0",
+    "@totemsdk/storage": "^0.2.0",
     "@totemsdk/omnia-vtxo": "^0.6.1",
-    "@totemsdk/minima-rpc": "^0.4.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": {