@totemsdk/omnia-host 0.11.0 → 0.12.0

package/dist/lifecycle.d.ts

@@ -1,5 +1,6 @@
 import type { OmniaHostConfig } from './config.js';
 import { ObservationBus } from './observe/bus.js';
+import { SyncSqliteStore } from '@totemsdk/storage/sqlite-sync';
 import type { ObservationStore } from './observe/types.js';
 import type { OmniaSwarm, ChannelSigner, WotsLeaseProviderLike, MinimalChainProvider } from '@totemsdk/omnia';
 import { createOmniaSwarm } from '@totemsdk/omnia';
@@ -55,6 +56,8 @@ export interface OmniaHostDependencies {
     /** Observation feed: inject a store/bus (tests/embedding) or disable it. */
     observationStore?: ObservationStore;
     observationBus?: ObservationBus;
+    /** Synchronous storage adapter for durable factories/splices/VTXOs/pools. */
+    hostStateStore?: SyncSqliteStore;
     observe?: boolean;
     networkId?: string;
     sourceNodeId?: string;

package/dist/lifecycle.js

@@ -9,6 +9,8 @@ const bus_js_1 = require("./observe/bus.js");
 const emitter_js_1 = require("./observe/emitter.js");
 const store_js_1 = require("./observe/store.js");
 const snapshot_js_1 = require("./observe/snapshot.js");
+const sqlite_sync_1 = require("@totemsdk/storage/sqlite-sync");
+const persistent_map_js_1 = require("./stores/persistent-map.js");
 const omnia_1 = require("@totemsdk/omnia");
 const sqlite_store_js_1 = require("./stores/sqlite-store.js");
 const operations_js_1 = require("./stores/operations.js");
@@ -37,6 +39,8 @@ function createOmniaHost(config, dependencies = {}) {
     let ownedOperationStore;
     let observationStore = dependencies.observationStore;
     let ownedObservationStore;
+    let hostStateStore = dependencies.hostStateStore;
+    let ownedHostStateStore;
     const observationBus = dependencies.observationBus ?? new bus_js_1.ObservationBus();
     let observation;
     let controlServer = dependencies.controlServer;
@@ -90,6 +94,16 @@ function createOmniaHost(config, dependencies = {}) {
                     sourceNodeId: config.sourceNodeId ?? dependencies.sourceNodeId ?? config.localPartyId ?? 'omnia-host',
                 });
             }
+            if (!hostStateStore) {
+                try {
+                    ownedHostStateStore = new sqlite_sync_1.SyncSqliteStore(config.dbPath);
+                    hostStateStore = ownedHostStateStore;
+                }
+                catch (err) {
+                    console.error('[omnia-host] host-state store disabled:', err instanceof Error ? err.message : String(err));
+                }
+            }
+            const hostMap = (namespace, injected) => injected ?? (hostStateStore ? new persistent_map_js_1.PersistentMap(hostStateStore, namespace) : new Map());
             if (!swarm) {
                 const relay = config.relay
                     ? { mode: 'self-hosted', relayUrl: config.relay }
@@ -156,7 +170,7 @@ function createOmniaHost(config, dependencies = {}) {
                     },
                 }
                 : undefined);
-            const factories = dependencies.factories ?? (factoryBundles ? new Map() : undefined);
+            const factories = dependencies.factories ?? (factoryBundles ? hostMap('omnia:factory:') : undefined);
             const localBundle = localParticipant
                 ? factoryBundles?.[localParticipant.partyId]
                 : undefined;
@@ -169,8 +183,8 @@ function createOmniaHost(config, dependencies = {}) {
                         : {}),
                 }
                 : undefined);
-            const spliceProposals = dependencies.spliceProposals ?? new Map();
-            const spliceAcceptances = dependencies.spliceAcceptances ?? new Map();
+            const spliceProposals = hostMap('omnia:splice:proposal:', dependencies.spliceProposals);
+            const spliceAcceptances = hostMap('omnia:splice:acceptance:', dependencies.spliceAcceptances);
             const onSpliceMessage = async (peer, msg) => {
                 if (!spliceLeaseProvider || !channelStore)
                     return;
@@ -449,12 +463,12 @@ function createOmniaHost(config, dependencies = {}) {
             const preparedOpen = new Map();
             const preparedSplice = new Map();
             const preparedFactory = new Map();
-            const vtxoPools = new Map();
-            const vtxos = new Map();
-            const vtxoReceipts = new Map();
+            const vtxoPools = hostMap('omnia:vtxo:pool:');
+            const vtxos = hostMap('omnia:vtxo:');
+            const vtxoReceipts = hostMap('omnia:vtxo:receipt:');
             const preparedVtxoReceipts = new Map();
-            const pools = new Map();
-            const poolPositions = new Map();
+            const pools = hostMap('omnia:pool:');
+            const poolPositions = hostMap('omnia:pool:position:');
             if (!controlServer) {
                 const readOnly = !dependencies.signer || !dependencies.leaseProvider;
                 if (readOnly) {
@@ -567,6 +581,8 @@ function createOmniaHost(config, dependencies = {}) {
             if (ownedObservationStore)
                 await ownedObservationStore.close();
             ownedObservationStore = undefined;
+            ownedHostStateStore?.close();
+            ownedHostStateStore = undefined;
             ownedStore?.close();
             ownedStore = undefined;
             started = false;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/omnia-host",
-  "version": "0.11.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",
@@ -22,20 +22,20 @@
   ],
   "dependencies": {
     "ws": "^8.21.1",
+    "@totemsdk/chain-provider": "^0.3.0",
     "@totemsdk/core": "^1.4.0",
     "@totemsdk/identity": "^1.0.2",
-    "@totemsdk/chain-provider": "^0.3.0",
     "@totemsdk/liquidity-bond": "^0.3.1",
-    "@totemsdk/manifest": "^2.0.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-pool": "^0.5.3",
     "@totemsdk/omnia-splice": "^0.3.0",
+    "@totemsdk/omnia-pool": "^0.5.3",
     "@totemsdk/p2p-hub": "^0.1.0",
-    "@totemsdk/omnia-vtxo": "^0.6.1",
     "@totemsdk/storage": "^0.2.0",
+    "@totemsdk/omnia-vtxo": "^0.6.1",
     "@totemsdk/wots-lease": "^1.0.1"
   },
   "devDependencies": {