@totemsdk/omnia-host 0.1.0

package/dist/stores/analytics.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDbAnalyticsStore = exports.DisabledAnalyticsStore = void 0;
+exports.initializeDuckDb = initializeDuckDb;
+/**
+ * No-op analytics backend for phase 9 deployments without DuckDB enabled.
+ * The interface keeps analytics off the channel critical path.
+ */
+class DisabledAnalyticsStore {
+    async append(_event) { }
+    async query(_kind, _limit) { return []; }
+    async close() { }
+}
+exports.DisabledAnalyticsStore = DisabledAnalyticsStore;
+class DuckDbAnalyticsStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async append(event) {
+        await this.db.run(`INSERT INTO omnia_events (event_id, kind, occurred_at, channel_id, operation_id, payload_json)
+       VALUES (?, ?, ?, ?, ?, ?)`, event.eventId, event.kind, event.occurredAt, event.channelId ?? null, event.operationId ?? null, JSON.stringify(event.payload));
+    }
+    async query(kind, limit = 100) {
+        const rows = await this.db.all(kind
+            ? 'SELECT * FROM omnia_events WHERE kind = ? ORDER BY occurred_at DESC LIMIT ?'
+            : 'SELECT * FROM omnia_events ORDER BY occurred_at DESC LIMIT ?', ...(kind ? [kind, limit] : [limit]));
+        return rows.map((row) => ({
+            eventId: row.event_id,
+            kind: row.kind,
+            occurredAt: row.occurred_at,
+            channelId: row.channel_id,
+            operationId: row.operation_id,
+            payload: JSON.parse(row.payload_json),
+        }));
+    }
+    close() {
+        return this.db.close();
+    }
+}
+exports.DuckDbAnalyticsStore = DuckDbAnalyticsStore;
+async function initializeDuckDb(db) {
+    await db.run(`
+    CREATE TABLE IF NOT EXISTS omnia_events (
+      event_id VARCHAR PRIMARY KEY,
+      kind VARCHAR NOT NULL,
+      occurred_at BIGINT NOT NULL,
+      channel_id VARCHAR,
+      operation_id VARCHAR,
+      payload_json VARCHAR NOT NULL
+    )
+  `);
+}

package/dist/stores/operations.d.ts

@@ -0,0 +1,25 @@
+export type OperationStatus = 'pending' | 'reserved' | 'executing' | 'committed' | 'failed' | 'unknown';
+export interface OperationRecord {
+    operationId: string;
+    status: OperationStatus;
+    createdAt: number;
+    updatedAt: number;
+    request?: unknown;
+    requestDigest?: string;
+    result?: unknown;
+    error?: string;
+}
+/** Durable operation journal with atomic status transitions. */
+export declare class OperationStore {
+    private readonly db;
+    constructor(dbPath: string);
+    get(operationId: string): OperationRecord | undefined;
+    create(operationId: string, request?: unknown, now?: number): OperationRecord;
+    verifyRequest(operationId: string, request: unknown): boolean;
+    transition(operationId: string, from: OperationStatus, to: OperationStatus, patch?: {
+        result?: unknown;
+        error?: string;
+    }, now?: number): OperationRecord;
+    listByStatus(status: OperationStatus): OperationRecord[];
+    close(): void;
+}

package/dist/stores/operations.js

@@ -0,0 +1,101 @@
+"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");
+function encode(value) {
+    return value === undefined ? null : JSON.stringify(value);
+}
+function decode(value) {
+    return value === null ? undefined : JSON.parse(value);
+}
+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,
+    };
+}
+/** Durable operation journal with atomic status transitions. */
+class OperationStore {
+    db;
+    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');
+        }
+    }
+    get(operationId) {
+        const row = this.db.prepare('SELECT * FROM omnia_operations WHERE operation_id = ?').get(operationId);
+        return row ? toRecord(row) : 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;
+    }
+    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)
+                throw new Error(`Unknown operation ${operationId}`);
+            throw new Error(`Operation ${operationId} expected status ${from} but is ${current.status}`);
+        }
+        return this.get(operationId);
+    }
+    listByStatus(status) {
+        const rows = this.db.prepare('SELECT * FROM omnia_operations WHERE status = ? ORDER BY created_at').all(status);
+        return rows.map(toRecord);
+    }
+    close() {
+        this.db.close();
+    }
+}
+exports.OperationStore = OperationStore;
+function canonical(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonical).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

@@ -0,0 +1,21 @@
+import { type OmniaChannel } from '@totemsdk/omnia';
+/** SQLite-backed Map facade accepted by @totemsdk/omnia's ChannelStore type. */
+export declare class SqliteChannelStore extends Map<string, OmniaChannel> {
+    private readonly db;
+    private readonly readStatement;
+    private readonly writeStatement;
+    private readonly deleteStatement;
+    constructor(dbPath: string);
+    get(channelId: string): OmniaChannel | undefined;
+    set(channelId: string, channel: OmniaChannel): this;
+    has(channelId: string): boolean;
+    delete(channelId: string): boolean;
+    clear(): void;
+    get size(): number;
+    entries(): MapIterator<[string, OmniaChannel]>;
+    keys(): MapIterator<string>;
+    values(): MapIterator<OmniaChannel>;
+    [Symbol.iterator](): MapIterator<[string, OmniaChannel]>;
+    forEach(callbackfn: (value: OmniaChannel, key: string, map: Map<string, OmniaChannel>) => void): void;
+    close(): void;
+}

package/dist/stores/sqlite-store.js

@@ -0,0 +1,97 @@
+"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 omnia_1 = require("@totemsdk/omnia");
+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;
+        },
+    };
+}
+/** SQLite-backed Map facade accepted by @totemsdk/omnia's ChannelStore type. */
+class SqliteChannelStore extends Map {
+    db;
+    readStatement;
+    writeStatement;
+    deleteStatement;
+    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 = ?');
+    }
+    get(channelId) {
+        const row = this.readStatement.get(channelId);
+        return row ? (0, omnia_1.recoverChannel)(row.channel_json) : undefined;
+    }
+    set(channelId, channel) {
+        this.writeStatement.run(channelId, (0, omnia_1.serializeChannelSnapshot)(channel), Date.now());
+        return this;
+    }
+    has(channelId) {
+        return this.readStatement.get(channelId) !== undefined;
+    }
+    delete(channelId) {
+        return this.deleteStatement.run(channelId).changes > 0;
+    }
+    clear() {
+        this.db.exec('DELETE FROM omnia_channels');
+    }
+    get size() {
+        const row = this.db.prepare('SELECT COUNT(*) AS count FROM omnia_channels').get();
+        return row.count;
+    }
+    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,
+            (0, omnia_1.recoverChannel)(row.channel_json),
+        ]));
+    }
+    keys() {
+        return iterator(Array.from(this.entries(), ([channelId]) => channelId));
+    }
+    values() {
+        return iterator(Array.from(this.entries(), ([, channel]) => channel));
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(callbackfn) {
+        for (const [key, value] of this.entries())
+            callbackfn(value, key, this);
+    }
+    close() {
+        this.db.close();
+    }
+}
+exports.SqliteChannelStore = SqliteChannelStore;

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@totemsdk/omnia-host",
+  "version": "0.1.0",
+  "description": "Durable Omnia node daemon for channel lifecycle, routing, and control APIs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "omnia-host": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "better-sqlite3": "^12.2.0",
+    "ws": "^8.21.1",
+    "@totemsdk/chain-provider": "^0.1.5",
+    "@totemsdk/omnia": "^0.1.9",
+    "@totemsdk/omnia-factory": "^0.1.8",
+    "@totemsdk/omnia-router": "^0.1.5",
+    "@totemsdk/omnia-vtxo": "^0.1.0",
+    "@totemsdk/minima-rpc": "^0.1.4",
+    "@totemsdk/wots-lease": "^0.1.5",
+    "@totemsdk/omnia-splice": "^0.1.7"
+  },
+  "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",
+    "ts-jest": "^29.4.11",
+    "typescript": "5.9.3"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "Totem SDK",
+  "homepage": "https://totem.ing",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/totem-sdk/totem-sdk.git",
+    "directory": "packages/omnia-host"
+  },
+  "bugs": {
+    "url": "https://github.com/Totem-Edge/totem-sdk/issues"
+  },
+  "keywords": [
+    "totem",
+    "totemsdk",
+    "omnia",
+    "payment-channel",
+    "daemon",
+    "node"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "jest",
+    "start": "node dist/cli.js"
+  }
+}