@totemsdk/omnia-host 0.10.0 → 0.12.0

package/dist/chain/totem-node-adapter.js

@@ -38,7 +38,7 @@ function createTotemNodeAdapter(options) {
         getTokensByCreator: (address) => provider.getTokensByCreator(address),
         broadcastTxPoW: (txpowHex) => provider.broadcastTxPoW(txpowHex),
         getMinTxPowWork: () => provider.getMinTxPowWork ? provider.getMinTxPowWork() : Promise.resolve(null),
-        ...(provider.submitTransaction
+        ...(provider.submitTransaction && process.env.OMNIA_CHAIN_NO_TXNMINE !== '1'
             ? { submitTransaction: provider.submitTransaction.bind(provider) }
             : {}),
         async getMode() {

package/dist/cli.js

@@ -1,10 +1,74 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
 const index_js_1 = require("./index.js");
+const pairing_js_1 = require("./pairing.js");
 const signing_js_1 = require("./signing.js");
 const identity_js_1 = require("./identity.js");
+const signer_port_js_1 = require("./signer-port.js");
+async function runPair() {
+    const config = (0, index_js_1.loadConfigFromEnv)();
+    const port = Number(process.env.OMNIA_PAIR_PORT ?? 7789);
+    const host = process.env.OMNIA_PAIR_HOST ?? '127.0.0.1';
+    const origins = (process.env.OMNIA_PAIR_ORIGINS ?? '')
+        .split(',')
+        .map((value) => value.trim())
+        .filter(Boolean);
+    const capabilities = {
+        chain: { rpcUrl: config.chainRpcUrl, network: 'minima' },
+        lease: { modes: ['local', 'hybrid'] },
+        ...(config.p2pHubPort
+            ? {
+                p2p: {
+                    hubUrl: `ws://${config.p2pHubHost ?? '127.0.0.1'}:${config.p2pHubPort}`,
+                    scopes: ['p2p.pubsub'],
+                    ...(config.p2pHubTopics ? { topicPrefixes: config.p2pHubTopics } : {}),
+                },
+            }
+            : {}),
+    };
+    const service = (0, pairing_js_1.createPairingService)({
+        storePath: node_path_1.default.join(node_path_1.default.dirname(config.dbPath), 'pairing.json'),
+        endpoint: `http://${host}:${port}`,
+        network: 'minima',
+        capabilities,
+        ...(origins.length ? { allowedOrigins: origins } : {}),
+    });
+    const server = (0, pairing_js_1.createPairingHttpServer)(service, { host, port });
+    const address = await server.listen();
+    const invitation = service.createInvitation();
+    if (process.argv.includes('--json')) {
+        console.log(JSON.stringify({ ...invitation, endpoint: `http://${address.host}:${address.port}` }, null, 2));
+    }
+    else {
+        console.log('');
+        console.log('Pair this node with your Totem extension');
+        console.log('');
+        console.log(`Node:        ${service.nodeId}`);
+        console.log(`Network:     ${service.network}`);
+        console.log(`Fingerprint: ${service.fingerprint}`);
+        console.log(`Endpoint:    http://${address.host}:${address.port}`);
+        console.log(`Expires:     ${new Date(invitation.expiresAt).toISOString()}`);
+        console.log('');
+        console.log(`Code: ${invitation.code}`);
+        console.log('');
+        console.log('Open Totem → Settings → Pair Node and paste the endpoint + code.');
+    }
+    await new Promise((resolve) => {
+        process.once('SIGINT', resolve);
+        process.once('SIGTERM', resolve);
+    });
+    await server.close();
+}
 async function main() {
+    if (process.argv[2] === 'pair') {
+        await runPair();
+        return;
+    }
     const config = (0, index_js_1.loadConfigFromEnv)();
     const signing = config.readOnly || !(0, signing_js_1.hasSigningMaterial)(config)
         ? undefined
@@ -16,6 +80,7 @@ async function main() {
         ? {
             signer: signing.signer,
             leaseProvider: signing.leaseProvider,
+            signerPort: (0, signer_port_js_1.createLocalSignerPort)(signing),
             transportKeyPair: signing.transportKeyPair,
             transportPubkey: signing.transportPubkey,
             identity: identityAndManifest?.identity

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+import type { CustodyMode } from '@totemsdk/omnia';
 export interface OmniaHostConfig {
     port: number;
     host: string;
@@ -5,6 +6,14 @@ export interface OmniaHostConfig {
     chainRpcUrl: string;
     chainRpcPassword?: string;
     analyticsDbPath?: string;
+    /** Durable observation journal DB (default: alongside dbPath). */
+    observeDbPath?: string;
+    /** Observation network id (multi-network deployments). */
+    networkId?: string;
+    /** Stable observation source id (default: localPartyId or "omnia-host"). */
+    sourceNodeId?: string;
+    /** Disable the observation feed entirely (OMNIA_OBSERVE=0). */
+    observeDisabled?: boolean;
     relay?: string;
     localPubkey?: string;
     localPartyId?: string;
@@ -28,6 +37,11 @@ export interface OmniaHostConfig {
     deviceId?: string;
     /** "1" forces read-only mode even with keys present. */
     readOnly: boolean;
+    /**
+     * Deployment custody mode (RFC-058). Defaults to self-custody; hosted custody
+     * is explicit and policy-controlled. This does not change on-chain custody.
+     */
+    custodyMode?: CustodyMode;
     /** Identity file containing a delegated identity claim (operator root → service delegate). */
     identityFile?: string;
     /** EdgeServiceManifest serviceType (default "omnia-router"). */
@@ -42,6 +56,12 @@ export interface OmniaHostConfig {
      * Undefined disables token auth.
      */
     controlToken?: string;
+    /** RFC-062 local P2P hub (optional). One Hyperswarm shared by dapps. */
+    p2pHubPort?: number;
+    p2pHubHost?: string;
+    p2pHubToken?: string;
+    p2pHubOrigins?: string[];
+    p2pHubTopics?: string[];
 }
 /** Load the daemon configuration from the documented OMNIA_* environment. */
 export declare function loadConfigFromEnv(env?: NodeJS.ProcessEnv): OmniaHostConfig;

package/dist/config.js

@@ -35,6 +35,27 @@ function parseOrigins(value) {
         .filter((part) => part.length > 0);
     return parts && parts.length > 0 ? parts : undefined;
 }
+function parseOptionalPort(value, name) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return undefined;
+    const port = Number(trimmed);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`${name} must be an integer between 1 and 65535; received ${value}`);
+    }
+    return port;
+}
+function parseList(value) {
+    const parts = value?.split(',').map((part) => part.trim()).filter(Boolean);
+    return parts && parts.length > 0 ? parts : undefined;
+}
+function parseCustodyMode(value) {
+    const mode = optional(value) ?? 'self';
+    if (mode !== 'self' && mode !== 'trust-minimised' && mode !== 'hosted') {
+        throw new Error(`OMNIA_CUSTODY must be self, trust-minimised or hosted; received ${value}`);
+    }
+    return mode;
+}
 function parseSeed(value) {
     const seed = optional(value);
     if (!seed)
@@ -62,13 +83,18 @@ function loadConfigFromEnv(env = process.env) {
     if (seed && keyfile) {
         throw new Error('OMNIA_HOST_SEED and OMNIA_HOST_KEYFILE are mutually exclusive — set exactly one of them');
     }
+    const dbPath = env.OMNIA_HOST_DB?.trim() || node_path_1.default.join(dataRoot, 'omnia.sqlite');
     return {
         port: parsePort(env.OMNIA_HOST_PORT),
         host: env.OMNIA_HOST_BIND?.trim() || '127.0.0.1',
-        dbPath: env.OMNIA_HOST_DB?.trim() || node_path_1.default.join(dataRoot, 'omnia.sqlite'),
+        dbPath,
         chainRpcUrl: env.OMNIA_CHAIN_RPC?.trim() || 'http://127.0.0.1:9005',
         chainRpcPassword: optional(env.OMNIA_CHAIN_RPC_PASSWORD),
         analyticsDbPath: optional(env.OMNIA_ANALYTICS_DB),
+        observeDbPath: optional(env.OMNIA_OBSERVE_DB) ?? node_path_1.default.join(node_path_1.default.dirname(dbPath), 'observe.sqlite'),
+        networkId: optional(env.OMNIA_NETWORK_ID),
+        sourceNodeId: optional(env.OMNIA_SOURCE_NODE_ID),
+        observeDisabled: env.OMNIA_OBSERVE?.trim() === '0' || env.OMNIA_OBSERVE?.trim().toLowerCase() === 'false',
         relay: optional(env.OMNIA_RELAY),
         localPubkey: optional(env.OMNIA_LOCAL_PUBKEY),
         localPartyId: optional(env.OMNIA_LOCAL_PARTY_ID),
@@ -82,9 +108,15 @@ function loadConfigFromEnv(env = process.env) {
         keyfilePassphrase: optional(env.OMNIA_HOST_KEYFILE_PASSPHRASE),
         deviceId: optional(env.OMNIA_HOST_DEVICE_ID),
         readOnly: env.OMNIA_HOST_READ_ONLY?.trim() === '1',
+        custodyMode: parseCustodyMode(env.OMNIA_CUSTODY),
         identityFile: optional(env.OMNIA_HOST_IDENTITY_FILE),
         serviceType: optional(env.OMNIA_HOST_SERVICE_TYPE) ?? 'omnia-router',
         allowedOrigins: parseOrigins(env.OMNIA_ALLOWED_ORIGINS),
+        p2pHubPort: parseOptionalPort(env.OMNIA_P2P_HUB_PORT, 'OMNIA_P2P_HUB_PORT'),
+        p2pHubHost: optional(env.OMNIA_P2P_HUB_HOST),
+        p2pHubToken: optional(env.OMNIA_P2P_HUB_TOKEN),
+        p2pHubOrigins: parseOrigins(env.OMNIA_P2P_HUB_ORIGINS),
+        p2pHubTopics: parseList(env.OMNIA_P2P_HUB_TOPICS),
         controlToken: optional(env.OMNIA_CONTROL_TOKEN),
     };
 }

package/dist/index.d.ts

@@ -19,3 +19,6 @@ export type { HostApiContext } from './api/methods.js';
 export type { OperationStoreLike } from './api/methods.js';
 export { DisabledAnalyticsStore, DuckDbAnalyticsStore, initializeDuckDb } from './stores/analytics.js';
 export type { AnalyticsEvent, AnalyticsStore, DuckDbConnection } from './stores/analytics.js';
+export { createLocalSignerPort, createPolicySignerPort } from './signer-port.js';
+export type { SignerPolicy } from './signer-port.js';
+export * from './observe/index.js';

package/dist/index.js

@@ -1,6 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeDuckDb = exports.DuckDbAnalyticsStore = exports.DisabledAnalyticsStore = exports.createHostMethods = exports.GoRoutingProvider = exports.InProcessRoutingProvider = exports.createTotemNodeAdapter = exports.OperationStore = exports.SqliteChannelStore = exports.loadHostIdentity = exports.createHostManifest = exports.createHostIdentityAndManifest = exports.encryptSeedForKeyfile = exports.leaseStorageDir = exports.JsonFileStorageAdapter = exports.hasSigningMaterial = exports.createHostSigning = exports.createOmniaHost = exports.loadConfigFromEnv = void 0;
+exports.createPolicySignerPort = exports.createLocalSignerPort = exports.initializeDuckDb = exports.DuckDbAnalyticsStore = exports.DisabledAnalyticsStore = exports.createHostMethods = exports.GoRoutingProvider = exports.InProcessRoutingProvider = exports.createTotemNodeAdapter = exports.OperationStore = exports.SqliteChannelStore = exports.loadHostIdentity = exports.createHostManifest = exports.createHostIdentityAndManifest = exports.encryptSeedForKeyfile = exports.leaseStorageDir = exports.JsonFileStorageAdapter = exports.hasSigningMaterial = exports.createHostSigning = exports.createOmniaHost = exports.loadConfigFromEnv = void 0;
 var config_js_1 = require("./config.js");
 Object.defineProperty(exports, "loadConfigFromEnv", { enumerable: true, get: function () { return config_js_1.loadConfigFromEnv; } });
 var lifecycle_js_1 = require("./lifecycle.js");
@@ -31,3 +45,8 @@ var analytics_js_1 = require("./stores/analytics.js");
 Object.defineProperty(exports, "DisabledAnalyticsStore", { enumerable: true, get: function () { return analytics_js_1.DisabledAnalyticsStore; } });
 Object.defineProperty(exports, "DuckDbAnalyticsStore", { enumerable: true, get: function () { return analytics_js_1.DuckDbAnalyticsStore; } });
 Object.defineProperty(exports, "initializeDuckDb", { enumerable: true, get: function () { return analytics_js_1.initializeDuckDb; } });
+var signer_port_js_1 = require("./signer-port.js");
+Object.defineProperty(exports, "createLocalSignerPort", { enumerable: true, get: function () { return signer_port_js_1.createLocalSignerPort; } });
+Object.defineProperty(exports, "createPolicySignerPort", { enumerable: true, get: function () { return signer_port_js_1.createPolicySignerPort; } });
+// Durable, replayable observation feed (RFC-0011 Amendment A).
+__exportStar(require("./observe/index.js"), exports);

package/dist/lifecycle.d.ts

@@ -1,4 +1,7 @@
 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';
 import { OperationStore } from './stores/operations.js';
@@ -7,6 +10,7 @@ import { type ControlServer } from './api/jsonrpc.js';
 import { type TotemNodeAdapter } from './chain/totem-node-adapter.js';
 import { type RoutingProvider } from './router/routing-provider.js';
 import type { JsonRpcHandler } from './api/jsonrpc.js';
+import { type HubNetwork } from '@totemsdk/p2p-hub';
 import { type OperationStoreLike } from './api/methods.js';
 import type { ChannelFactory, WotsLeaseBundle } from '@totemsdk/omnia-factory';
 import type { SpliceAcceptance, SpliceLeaseProvider, SpliceProposal } from '@totemsdk/omnia-splice';
@@ -17,6 +21,8 @@ export interface OmniaHostDependencies {
     operationStore?: OperationStore | Pick<OperationStore, 'close'>;
     signer?: ChannelSigner;
     leaseProvider?: WotsLeaseProviderLike;
+    /** RFC-058 signer port; defaults to a local signer in CLI deployments. */
+    signerPort?: import('@totemsdk/omnia').SignerPort;
     chainProvider?: MinimalChainProvider;
     controlServer?: ControlServer;
     chainAdapter?: TotemNodeAdapter;
@@ -45,6 +51,16 @@ export interface OmniaHostDependencies {
     };
     /** Boot-time signed EdgeServiceManifest (getManifest). */
     manifest?: unknown;
+    /** Optional P2P hub network (tests/embedding). */
+    p2pHubNetwork?: HubNetwork;
+    /** 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;
 }
 export interface OmniaHost {
     readonly config: OmniaHostConfig;
@@ -53,6 +69,8 @@ export interface OmniaHost {
     isStarted(): boolean;
     readonly swarm?: OmniaSwarm;
     readonly channels?: Map<string, OmniaChannel>;
+    /** Loopback WebSocket endpoint for local dapps, when enabled (RFC-062). */
+    readonly p2pHubUrl?: string;
 }
 /**
  * Phase-1 lifecycle shell. Subsystems will be attached in later phases while

package/dist/lifecycle.js

@@ -1,12 +1,23 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOmniaHost = createOmniaHost;
+const node_path_1 = __importDefault(require("node:path"));
+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");
 const jsonrpc_js_1 = require("./api/jsonrpc.js");
 const totem_node_adapter_js_1 = require("./chain/totem-node-adapter.js");
 const routing_provider_js_1 = require("./router/routing-provider.js");
+const p2p_hub_1 = require("@totemsdk/p2p-hub");
 const methods_js_1 = require("./api/methods.js");
 const reply_cache_js_1 = require("./reply-cache.js");
 const omnia_factory_1 = require("@totemsdk/omnia-factory");
@@ -26,9 +37,17 @@ function createOmniaHost(config, dependencies = {}) {
         : undefined;
     const injectedOperationStore = dependencies.operationStore;
     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;
     let chainAdapter = dependencies.chainAdapter;
     let routingProvider = dependencies.routingProvider ?? new routing_provider_js_1.InProcessRoutingProvider();
+    let p2pHubServer;
+    let p2pHubUrl;
     return {
         config,
         get swarm() {
@@ -37,6 +56,9 @@ function createOmniaHost(config, dependencies = {}) {
         get channels() {
             return channelStore;
         },
+        get p2pHubUrl() {
+            return p2pHubUrl;
+        },
         async start() {
             if (started)
                 return;
@@ -53,6 +75,35 @@ function createOmniaHost(config, dependencies = {}) {
                 ownedOperationStore = new operations_js_1.OperationStore(config.dbPath);
                 operationStore = ownedOperationStore;
             }
+            const observeEnabled = dependencies.observe === true || (dependencies.observe !== false && config.observeDisabled !== true && config.observeDbPath !== undefined);
+            if (observeEnabled && !observationStore) {
+                const observePath = config.observeDbPath ?? node_path_1.default.join(node_path_1.default.dirname(config.dbPath), 'observe.sqlite');
+                try {
+                    ownedObservationStore = await (0, store_js_1.createSqliteObservationStore)(observePath);
+                    observationStore = ownedObservationStore;
+                }
+                catch (err) {
+                    console.error('[omnia-host] observation store disabled:', err instanceof Error ? err.message : String(err));
+                }
+            }
+            if (observationStore) {
+                observation = new emitter_js_1.ObservationEmitter({
+                    store: observationStore,
+                    bus: observationBus,
+                    networkId: config.networkId ?? dependencies.networkId ?? 'omnia',
+                    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 }
@@ -85,6 +136,21 @@ function createOmniaHost(config, dependencies = {}) {
                     ssl: rpc.protocol === 'https:',
                 });
             }
+            if (config.p2pHubPort !== undefined || dependencies.p2pHubNetwork) {
+                const native = swarm.nativeSwarm?.();
+                const network = dependencies.p2pHubNetwork ?? await (0, p2p_hub_1.createHyperswarmHubNetwork)(native ? { swarm: native } : {});
+                p2pHubServer = await (0, p2p_hub_1.createWebSocketHubServer)({
+                    network,
+                    host: config.p2pHubHost ?? '127.0.0.1',
+                    port: config.p2pHubPort ?? 0,
+                    ...(config.p2pHubToken ? { token: config.p2pHubToken } : {}),
+                    ...(config.p2pHubOrigins ? { allowedOrigins: config.p2pHubOrigins } : {}),
+                    ...(config.p2pHubTopics ? { allowedTopicPrefixes: config.p2pHubTopics } : {}),
+                });
+                const address = await p2pHubServer.listen();
+                const host = address.host.includes(':') ? `[${address.host}]` : address.host;
+                p2pHubUrl = `ws://${host}:${address.port}`;
+            }
             const localParticipant = dependencies.localParticipant ?? (config.localPartyId && config.localPubkey && config.localAddressIndex !== undefined
                 ? {
                     partyId: config.localPartyId,
@@ -104,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;
@@ -117,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;
@@ -158,6 +224,12 @@ function createOmniaHost(config, dependencies = {}) {
                     if (msg.type === 'SPLICE_FINALIZED' && payload.channel) {
                         const channel = payload.channel;
                         channelStore.set(channel.channelId, channel);
+                        void observation?.emit({
+                            domain: 'splice', kind: 'splice.finalized', phase: 'confirmed',
+                            entity: { type: 'channel', id: channel.channelId },
+                            amounts: { capacity: channel.totalValue?.toString(), balances: Object.fromEntries(Object.entries(channel.balances ?? {}).map(([k, v]) => [k, v.toString()])) },
+                            data: { spliceId: payload.spliceId, txId: payload.txId },
+                        });
                         const acceptance = spliceAcceptances.get(payload.spliceId);
                         if (acceptance && typeof payload.txId === 'string') {
                             await spliceLeaseProvider.wotsLease
@@ -217,6 +289,11 @@ function createOmniaHost(config, dependencies = {}) {
                         if (msg.type === 'FACTORY_PROPOSAL' && payload.factory) {
                             const accepted = await (0, omnia_factory_1.acceptFactory)(payload.factory, localBundle);
                             factories.set(accepted.factoryId, accepted);
+                            void observation?.emit({
+                                domain: 'factory', kind: 'factory.accepted', phase: 'accepted',
+                                entity: { type: 'factory', id: accepted.factoryId },
+                                data: { participants: accepted.participants },
+                            });
                             return {
                                 type: 'FACTORY_ACCEPT',
                                 channelId: accepted.factoryId,
@@ -261,6 +338,47 @@ function createOmniaHost(config, dependencies = {}) {
                 if (reply)
                     await peer.sendMessage(reply);
             };
+            const channelPeers = new Map();
+            const onPeerMessage = (peer, msg) => {
+                if (msg?.channelId)
+                    channelPeers.set(msg.channelId, peer);
+                void observation?.emit({
+                    domain: 'transport', kind: 'transport.message', phase: 'observed',
+                    entity: { type: 'node', id: config.sourceNodeId ?? config.localPartyId ?? 'omnia-host' },
+                    evidence: { peerPublicKeyDigest: peer?.publicKeyDigest },
+                    data: { type: msg?.type, channelId: msg?.channelId, nonce: msg?.nonce },
+                });
+            };
+            const onChannelAccepted = (channel, peer) => {
+                void observation?.emit({
+                    domain: 'channel', kind: 'channel.proposal.accepted', phase: 'accepted',
+                    entity: { type: 'channel', id: channel.channelId },
+                    parties: { local: localParticipant?.partyId, remote: channel.parties?.find((p) => p.partyId !== localParticipant?.partyId)?.partyId },
+                    token: { tokenId: channel.tokenId, scale: channel.tokenScale ?? 0 },
+                    amounts: { capacity: channel.totalValue?.toString(), balances: Object.fromEntries(Object.entries(channel.balances ?? {}).map(([k, v]) => [k, v.toString()])) },
+                    transitionHash: (0, emitter_js_1.channelTransitionHash)(channel),
+                    evidence: { peerPublicKeyDigest: peer?.publicKeyDigest },
+                });
+            };
+            const onStateUpdated = (channel, peer) => {
+                void observation?.emit({
+                    domain: 'channel', kind: 'channel.updated', phase: 'committed',
+                    entity: { type: 'channel', id: channel.channelId },
+                    parties: { local: localParticipant?.partyId, remote: channel.parties?.find((p) => p.partyId !== localParticipant?.partyId)?.partyId },
+                    token: { tokenId: channel.tokenId, scale: channel.tokenScale ?? 0 },
+                    after: { sequence: channel.currentSequence, balances: Object.fromEntries(Object.entries(channel.balances ?? {}).map(([k, v]) => [k, v.toString()])) },
+                    transitionHash: (0, emitter_js_1.channelTransitionHash)(channel),
+                    evidence: { peerPublicKeyDigest: peer?.publicKeyDigest },
+                });
+            };
+            const onSettlementProposed = (payload, peer) => {
+                void observation?.emit({
+                    domain: 'settlement', kind: 'settlement.proposed', phase: 'proposed',
+                    entity: { type: 'channel', id: payload?.channelId ?? 'unknown' },
+                    evidence: { peerPublicKeyDigest: peer?.publicKeyDigest },
+                    data: { payload },
+                });
+            };
             const onVcMessage = async (peer, msg) => {
                 if (!factories || !localBundle)
                     return;
@@ -270,9 +388,19 @@ function createOmniaHost(config, dependencies = {}) {
                         factories.set(payload.factory.factoryId, payload.factory);
                     if (payload.kind === 'vc-open' && payload.channel) {
                         channelStore?.set(payload.channel.channelId, payload.channel);
+                        void observation?.emit({
+                            domain: 'factory', kind: 'factory.vc_opened', phase: 'accepted',
+                            entity: { type: 'channel', id: payload.channel.channelId },
+                            data: { factoryId: payload.factory?.factoryId },
+                        });
                     }
                     else if (payload.kind === 'vc-close' && payload.channelId) {
                         channelStore?.delete(payload.channelId);
+                        void observation?.emit({
+                            domain: 'factory', kind: 'factory.vc_closed', phase: 'closed',
+                            entity: { type: 'channel', id: payload.channelId },
+                            data: { factoryId: payload.factory?.factoryId },
+                        });
                     }
                     return;
                 }
@@ -325,7 +453,22 @@ function createOmniaHost(config, dependencies = {}) {
                 onFactoryMessage,
                 onVcMessage,
                 onSpliceMessage,
+                onPeerMessage,
+                onChannelAccepted,
+                onStateUpdated,
+                onSettlementProposed,
             });
+            const preparedPay = new Map();
+            const preparedSettle = new Map();
+            const preparedOpen = new Map();
+            const preparedSplice = new Map();
+            const preparedFactory = 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 = hostMap('omnia:pool:');
+            const poolPositions = hostMap('omnia:pool:position:');
             if (!controlServer) {
                 const readOnly = !dependencies.signer || !dependencies.leaseProvider;
                 if (readOnly) {
@@ -338,14 +481,32 @@ function createOmniaHost(config, dependencies = {}) {
                     isReady: () => started,
                     allowedOrigins: config.allowedOrigins,
                     authToken: config.controlToken,
+                    observe: observationStore ? {
+                        store: observationStore,
+                        bus: observationBus,
+                        snapshot: async () => (0, snapshot_js_1.createObservationSnapshot)({
+                            networkId: config.networkId ?? dependencies.networkId ?? 'omnia',
+                            sourceNodeId: config.sourceNodeId ?? dependencies.sourceNodeId ?? config.localPartyId ?? 'omnia-host',
+                            streamId: `${config.sourceNodeId ?? dependencies.sourceNodeId ?? config.localPartyId ?? 'omnia-host'}:${config.networkId ?? dependencies.networkId ?? 'omnia'}`,
+                            cursor: await observationStore.head(),
+                            channels: channelStore?.values(),
+                            factories: factories?.values(),
+                            vtxoPools: vtxoPools.values(),
+                            vtxos: vtxos.values(),
+                            pools: pools.values(),
+                            operations: (dependencies.operationStoreForApi ?? operationStore),
+                        }),
+                    } : undefined,
                     methods: dependencies.methods ?? (0, methods_js_1.createHostMethods)({
                         channels: channelStore,
                         routing: routingProvider,
                         operations: dependencies.operationStoreForApi ?? operationStore,
+                        observe: observation,
                         signer: dependencies.signer,
                         leaseProvider: dependencies.leaseProvider,
                         chainProvider: dependencies.chainProvider ?? chainAdapter,
                         swarm,
+                        channelPeers,
                         localParticipant,
                         transportPubkey: dependencies.transportPubkey,
                         factories,
@@ -353,6 +514,20 @@ function createOmniaHost(config, dependencies = {}) {
                         spliceProposals,
                         spliceAcceptances,
                         spliceLeaseProvider,
+                        custodyMode: config.custodyMode ?? 'self',
+                        signerPort: dependencies.signerPort,
+                        preparedPay,
+                        preparedSettle,
+                        preparedOpen,
+                        preparedSplice,
+                        preparedFactory,
+                        vtxoPools,
+                        vtxos,
+                        vtxoReceipts,
+                        preparedVtxoReceipts,
+                        pools,
+                        poolPositions,
+                        coordinator: !dependencies.signer && !config.readOnly,
                         fundingSigner: config.fundingPubkey
                             ? async (digest) => {
                                 const sig = await chainAdapter.signData(config.fundingPubkey, '0x' + Buffer.from(digest).toString('hex'));
@@ -362,6 +537,7 @@ function createOmniaHost(config, dependencies = {}) {
                         readOnly,
                         identity: dependencies.identity,
                         manifest: dependencies.manifest,
+                        p2pHubUrl,
                         refreshRouting: () => routingProvider.rebuild((0, routing_provider_js_1.channelGraphEdges)(channelStore.values())),
                     }),
                 });
@@ -373,6 +549,9 @@ function createOmniaHost(config, dependencies = {}) {
             catch (error) {
                 unsubscribe?.();
                 unsubscribe = undefined;
+                await p2pHubServer?.close();
+                p2pHubServer = undefined;
+                p2pHubUrl = undefined;
                 chainAdapter?.close();
                 await swarm?.close();
                 if (ownedOperationStore)
@@ -388,6 +567,9 @@ function createOmniaHost(config, dependencies = {}) {
                 return;
             unsubscribe?.();
             unsubscribe = undefined;
+            await p2pHubServer?.close();
+            p2pHubServer = undefined;
+            p2pHubUrl = undefined;
             await controlServer?.close();
             chainAdapter?.close();
             await swarm?.close();
@@ -396,6 +578,11 @@ function createOmniaHost(config, dependencies = {}) {
             else if (injectedOperationStore)
                 await injectedOperationStore.close();
             ownedOperationStore = undefined;
+            if (ownedObservationStore)
+                await ownedObservationStore.close();
+            ownedObservationStore = undefined;
+            ownedHostStateStore?.close();
+            ownedHostStateStore = undefined;
             ownedStore?.close();
             ownedStore = undefined;
             started = false;

package/dist/observe/bus.d.ts

@@ -0,0 +1,13 @@
+import type { OmniaObservation } from "./types.js";
+export type ObservationListener = (observation: OmniaObservation) => void;
+/**
+ * In-process live fan-out for SSE consumers. The durable journal remains the
+ * source of truth: a subscriber that misses a live event still replays it from
+ * `ObservationStore.readSince(cursor)`.
+ */
+export declare class ObservationBus {
+    private readonly listeners;
+    subscribe(listener: ObservationListener): () => void;
+    publish(observation: OmniaObservation): void;
+    get size(): number;
+}