@totemsdk/omnia-host 0.11.0 → 0.13.0

package/dist/api/methods.js

@@ -1697,21 +1697,7 @@ function createHostMethods(context) {
         });
         if (!route)
             return { success: false, error: 'No route found', errorCode: 'ROUTE_NOT_FOUND' };
-        return {
-            success: true,
-            route: {
-                ...route,
-                totalFees: route.totalFees.toString(),
-                hops: route.hops.map((hop) => ({
-                    ...hop,
-                    amount: hop.amount.toString(),
-                    ...('isSwap' in hop && hop.isSwap ? {
-                        amountIn: hop.amountIn.toString(),
-                        amountOut: hop.amountOut.toString(),
-                    } : {}),
-                })),
-            },
-        };
+        return { success: true, route: serializeWireRoute(route) };
     };
     register('totem_omniaGetRoute', getRoute, 'omnia/getRoute');
     const getSwapRate = () => ({ success: true, announcements: [] });
@@ -2529,28 +2515,115 @@ function createHostMethods(context) {
     };
     register('totem_omniaSpliceIn', splice('in'), 'omnia/spliceIn');
     register('totem_omniaSpliceOut', splice('out'), 'omnia/spliceOut');
+    function parseWireRoute(value) {
+        if (!value || typeof value !== 'object')
+            throw new Error('route must be an object');
+        const raw = value;
+        if (!Array.isArray(raw.hops) || raw.hops.length === 0)
+            throw new Error('route.hops must be a non-empty array');
+        const hops = raw.hops.map((entry, index) => {
+            if (!entry || typeof entry !== 'object')
+                throw new Error(`route.hops[${index}] must be an object`);
+            const hop = entry;
+            const base = {
+                channelId: String(hop.channelId ?? ''),
+                from: String(hop.from ?? ''),
+                to: String(hop.to ?? ''),
+                amount: typeof hop.amount === 'bigint' ? hop.amount : BigInt(String(hop.amount ?? '0')),
+                tokenId: String(hop.tokenId ?? ''),
+                ...(typeof hop.htlcId === 'string' ? { htlcId: hop.htlcId } : {}),
+            };
+            if (hop.isSwap === true) {
+                return {
+                    ...base,
+                    isSwap: true,
+                    tokenIn: String(hop.tokenIn ?? ''),
+                    tokenOut: String(hop.tokenOut ?? ''),
+                    amountIn: typeof hop.amountIn === 'bigint' ? hop.amountIn : BigInt(String(hop.amountIn ?? '0')),
+                    amountOut: typeof hop.amountOut === 'bigint' ? hop.amountOut : BigInt(String(hop.amountOut ?? '0')),
+                    rate: String(hop.rate ?? ''),
+                    inboundChannelId: String(hop.inboundChannelId ?? ''),
+                    outboundChannelId: String(hop.outboundChannelId ?? ''),
+                };
+            }
+            return base;
+        });
+        const route = {
+            hops,
+            totalFees: typeof raw.totalFees === 'bigint' ? raw.totalFees : BigInt(String(raw.totalFees ?? '0')),
+            tokenIn: String(raw.tokenIn ?? ''),
+            tokenOut: String(raw.tokenOut ?? ''),
+            estimatedBlocks: Number(raw.estimatedBlocks ?? 0),
+        };
+        if (hops.some((hop) => hop.isSwap)) {
+            route.swapHops = hops.filter((hop) => hop.isSwap);
+        }
+        return route;
+    }
+    function serializeWireRoute(route) {
+        return {
+            tokenIn: route.tokenIn,
+            tokenOut: route.tokenOut,
+            totalFees: route.totalFees.toString(),
+            estimatedBlocks: route.estimatedBlocks,
+            hops: route.hops.map((hop) => {
+                const base = {
+                    channelId: hop.channelId,
+                    from: hop.from,
+                    to: hop.to,
+                    amount: hop.amount.toString(),
+                    tokenId: hop.tokenId,
+                    ...(hop.htlcId ? { htlcId: hop.htlcId } : {}),
+                };
+                if ('isSwap' in hop && hop.isSwap) {
+                    return {
+                        ...base,
+                        isSwap: true,
+                        tokenIn: hop.tokenIn,
+                        tokenOut: hop.tokenOut,
+                        amountIn: hop.amountIn.toString(),
+                        amountOut: hop.amountOut.toString(),
+                        rate: hop.rate,
+                        inboundChannelId: hop.inboundChannelId,
+                        outboundChannelId: hop.outboundChannelId,
+                    };
+                }
+                return base;
+            }),
+        };
+    }
     const payMultiHop = async (raw) => {
         const params = paramsObject(raw);
         requireMutationContext(context);
-        const route = params.route;
-        if (!route || typeof route !== 'object' || !Array.isArray(route.hops)) {
-            throw new Error('route with hops is required');
-        }
-        const paymentRequest = params.paymentRequest;
-        if (!paymentRequest || typeof paymentRequest !== 'object') {
-            throw new Error('paymentRequest is required');
-        }
-        const request = paymentRequest;
+        const from = context.localParticipant?.publicKeyDigest;
+        if (!from)
+            throw new Error('Local participant is not configured');
+        const amount = requiredBigInt(params, 'amount');
+        const tokenId = requiredString(params, 'tokenId');
+        const targetTokenId = typeof params.targetTokenId === 'string' ? params.targetTokenId : undefined;
+        const parsedRoute = params.route
+            ? parseWireRoute(params.route)
+            : await context.routing.getRoute({
+                from,
+                to: normalizeRouteNode(requiredString(params, 'toPartyId')),
+                amount,
+                tokenId,
+                ...(targetTokenId ? { targetTokenId } : {}),
+                ...(typeof params.maxHops === 'number' ? { maxHops: params.maxHops } : {}),
+            });
+        if (!parsedRoute)
+            throw new Error('No route found');
+        const isCrossToken = parsedRoute.hops.some((hop) => 'isSwap' in hop && hop.isSwap === true);
         const parsedRequest = {
-            hashlock: requiredString(request, 'hashlock'),
-            amount: requiredBigInt(request, 'amount'),
-            tokenId: requiredString(request, 'tokenId'),
-            expiryBlock: requiredBigInt(request, 'expiryBlock'),
-            preimage: typeof request.preimage === 'string' ? request.preimage : undefined,
-            description: typeof request.description === 'string' ? request.description : undefined,
+            hashlock: requiredString(params, 'hashlock'),
+            amount,
+            tokenId,
+            expiryBlock: requiredBigInt(params, 'expiryBlock'),
+            ...(typeof params.preimage === 'string' ? { preimage: params.preimage } : {}),
+            ...(typeof params.description === 'string' ? { description: params.description } : {}),
         };
-        const parsedRoute = route;
-        const isCrossToken = 'swapHops' in parsedRoute && Array.isArray(parsedRoute.swapHops) && parsedRoute.swapHops.length > 0;
+        if (!parsedRequest.preimage)
+            throw new Error('preimage is required');
         const ops = {
             addHTLC: (channel, htlcParams, leaseProvider) => (0, omnia_1.addHTLC)(channel, htlcParams, leaseProvider, context.signer),
             fulfillHTLC: (channel, htlcId, preimage, leaseProvider) => (0, omnia_1.fulfillHTLC)(channel, htlcId, preimage, leaseProvider, context.signer),
@@ -2588,6 +2661,7 @@ function createHostMethods(context) {
                 success: true,
                 preimage: result.preimage,
                 settledHops: result.settledHops,
+                route: serializeWireRoute(parsedRoute),
             };
         });
     };

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.13.0",
   "description": "Durable Omnia node daemon for channel lifecycle, routing, and control APIs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,21 +22,21 @@
   ],
   "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-pool": "^0.5.3",
     "@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"
+    "@totemsdk/wots-lease": "^1.0.1",
+    "@totemsdk/storage": "^0.2.1",
+    "@totemsdk/p2p-hub": "^0.1.0"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",