@totemsdk/omnia-host 0.1.0 → 0.1.1

package/README.md

@@ -1,13 +1,16 @@
 # @totemsdk/omnia-host
 
-The Omnia host daemon will provide durable channel lifecycle, routing, chain
-integration, and control APIs for a Totem node. Phase 1 contains the package
-and lifecycle scaffold; subsystem implementations are added incrementally.
+The Omnia host daemon provides durable channel lifecycle, routing, chain
+integration, and control APIs for a Totem node. With signing material
+provisioned it runs fully operational; without it, it boots in read-only mode
+(channel/route/health queries only).
 
 ## Run
 
 ```bash
+OMNIA_HOST_SEED="your bip39 mnemonic or 0x…64-hex seed" \
 OMNIA_CHAIN_RPC_PASSWORD=secret pnpm --filter @totemsdk/omnia-host build
+OMNIA_HOST_SEED="your bip39 mnemonic or 0x…64-hex seed" \
 OMNIA_CHAIN_RPC_PASSWORD=secret pnpm --filter @totemsdk/omnia-host start
 ```
 
@@ -25,13 +28,45 @@ The daemon configuration is read from environment variables:
 | `OMNIA_LOCAL_PARTY_ID` | unset | Local channel party ID required for mutations |
 | `OMNIA_LOCAL_ADDRESS_INDEX` | unset | Local WOTS address index |
 | `OMNIA_LOCAL_SETTLEMENT_ADDRESS` | unset | Default cooperative settlement address |
+| `OMNIA_HOST_SEED` | unset | BIP39 mnemonic or 32-byte hex seed for channel signing |
+| `OMNIA_HOST_KEYFILE` | unset | Path to keyfile JSON (resolved against cwd); mutually exclusive with `OMNIA_HOST_SEED` |
+| `OMNIA_HOST_KEYFILE_PASSPHRASE` | unset | Keyfile decryption passphrase (required for encrypted keyfiles) |
+| `OMNIA_HOST_DEVICE_ID` | `device-<slot>` | Stable device id for the lease journal |
+| `OMNIA_HOST_READ_ONLY` | unset | `1` forces read-only mode even with keys present |
+| `OMNIA_HOST_IDENTITY_FILE` | unset | Optional delegated identity claim JSON (operator root → service delegate) |
+| `OMNIA_HOST_SERVICE_TYPE` | `omnia-router` | EdgeServiceManifest serviceType |
+
+### Signing model
+
+`OMNIA_HOST_SEED` (or the keyfile) is the base seed. The host derives a
+per-address seed (`derivePerAddressSeed(baseSeed, localAddressIndex)`) and
+signs every channel state with the flat WOTS key at index 0 of that seed; the
+channel participant's `publicKeyDigest` is `derivePKdigest(perAddressSeed, 0)`.
+The WOTS lease journal and watermark persist in `<OMNIA_HOST_DB>.lease/` so
+they survive restarts together with the channel database.
+
+### Read-only mode
+
+Without `OMNIA_HOST_SEED`/`OMNIA_HOST_KEYFILE` (or with `OMNIA_HOST_READ_ONLY=1`)
+the daemon logs `[omnia-host] no signing material; starting READ-ONLY` and
+registers only `getChannels`, `getRoute`, `getSwapRate`, `whoami`, and
+`getManifest`. Mutation methods are never registered without a signer.
+
+### Identity + manifest (opt-in)
+
+With signing material present, the daemon derives a service identity document
+from the seed and signs a boot-time `EdgeServiceManifest` (serviceType from
+`OMNIA_HOST_SERVICE_TYPE`). `OMNIA_HOST_IDENTITY_FILE` may supply a delegated
+identity claim (operator root → service delegate) validated via
+`verifyIdentityClaim`. Query them over JSON-RPC with `totem_omniaWhoami`
+(`omnia/whoami`) and `totem_omniaGetManifest` (`omnia/getManifest`).
 
 The daemon is intended to run beside `totem-node -mode omnia` or `-mode full`.
 The current implementation includes the swarm lifecycle wiring, SQLite and
 operation-store abstractions, JSON-RPC/WebSocket control API, route provider,
-chain adapter, Edge adapter contract, optional Go-router boundary, and DuckDB
-analytics abstraction. Funding/signing mutations remain capability-gated until
-a signer and WOTS lease provider are supplied.
+chain adapter, Edge adapter contract, optional Go-router boundary, DuckDB
+analytics abstraction, env-provisioned signer + WOTS lease provider, and
+multi-hop payment execution via `@totemsdk/omnia-router`.
 
 The local test environment may skip SQLite integration tests when the
 `better-sqlite3` native addon has not been built. Install lifecycle scripts in

package/dist/api/methods.d.ts

@@ -22,5 +22,16 @@ export interface HostApiContext {
     spliceProposals?: Map<string, SpliceProposal>;
     spliceAcceptances?: Map<string, SpliceAcceptance>;
     spliceLeaseProvider?: SpliceLeaseProvider;
+    /** When true, only read-only methods are registered (no signer material). */
+    readOnly?: boolean;
+    /** Opt-in host identity (address, publicKeyDigest, optional delegation). */
+    identity?: {
+        address: string;
+        publicKeyDigest: string;
+        identityId?: string;
+        delegation?: unknown;
+    };
+    /** Boot-time signed EdgeServiceManifest. */
+    manifest?: unknown;
 }
 export declare function createHostMethods(context: HostApiContext): Map<string, JsonRpcHandler>;

package/dist/api/methods.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHostMethods = createHostMethods;
 const omnia_1 = require("@totemsdk/omnia");
+const omnia_router_1 = require("@totemsdk/omnia-router");
 const omnia_factory_1 = require("@totemsdk/omnia-factory");
 const omnia_splice_1 = require("@totemsdk/omnia-splice");
 function channelSummary(channel) {
@@ -180,6 +181,30 @@ function createHostMethods(context) {
     register('totem_omniaGetRoute', getRoute, 'omnia/getRoute');
     const getSwapRate = () => ({ success: true, announcements: [] });
     register('totem_omniaGetSwapRate', getSwapRate, 'omnia/getSwapRate');
+    const whoami = () => {
+        if (!context.identity) {
+            return { address: null, publicKeyDigest: null };
+        }
+        return {
+            address: context.identity.address,
+            publicKeyDigest: context.identity.publicKeyDigest,
+            identityId: context.identity.identityId,
+            delegation: context.identity.delegation,
+        };
+    };
+    register('totem_omniaWhoami', whoami, 'omnia/whoami');
+    const getManifest = () => {
+        if (!context.manifest) {
+            return { manifest: null };
+        }
+        return { manifest: context.manifest };
+    };
+    register('totem_omniaGetManifest', getManifest, 'omnia/getManifest');
+    // Fail-fast rule: without signing material only the read-only surface is
+    // registered. Mutation methods must never exist without a signer.
+    if (context.readOnly || !context.signer || !context.leaseProvider) {
+        return methods;
+    }
     const openChannel = async (raw) => {
         const params = paramsObject(raw);
         requireMutationContext(context);
@@ -287,6 +312,15 @@ function createHostMethods(context) {
         const params = paramsObject(raw);
         requireMutationContext(context);
         const channelId = requiredString(params, 'channelId');
+        const broadcastProofs = params.broadcastProofs;
+        const parsedProofs = broadcastProofs && typeof broadcastProofs === 'object'
+            && Array.isArray(broadcastProofs.coinProofs)
+            && Array.isArray(broadcastProofs.scriptProofs)
+            ? {
+                coinProofs: broadcastProofs.coinProofs.map((hex) => Buffer.from(String(hex).replace(/^0x/i, ''), 'hex')),
+                scriptProofs: broadcastProofs.scriptProofs.map((hex) => Buffer.from(String(hex).replace(/^0x/i, ''), 'hex')),
+            }
+            : undefined;
         return withOperation(context, params, async () => {
             const channel = context.channels.get(channelId);
             if (!channel)
@@ -295,6 +329,7 @@ function createHostMethods(context) {
             const settlement = await (0, omnia_1.proposeSettlement)(closing, context.leaseProvider, {
                 signer: context.signer,
                 chainProvider: context.chainProvider,
+                broadcastProofs: parsedProofs,
                 partyAddresses: Object.fromEntries(closing.parties.map((party) => [party.partyId, party.settlementAddress ?? party.publicKeyDigest])),
             });
             context.channels.set(channelId, (0, omnia_1.markChannelClosed)(closing));
@@ -404,9 +439,56 @@ function createHostMethods(context) {
     };
     register('totem_omniaSpliceIn', splice('in'), 'omnia/spliceIn');
     register('totem_omniaSpliceOut', splice('out'), 'omnia/spliceOut');
-    const unsupported = () => {
-        throw new Error('This operation requires a counterparty proposal/acceptance round');
+    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 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,
+        };
+        const parsedRoute = route;
+        const isCrossToken = 'swapHops' in parsedRoute && Array.isArray(parsedRoute.swapHops) && parsedRoute.swapHops.length > 0;
+        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),
+            timeoutHTLC: (channel, htlcId, leaseProvider) => (0, omnia_1.timeoutHTLC)(channel, htlcId, leaseProvider, context.chainProvider, context.signer),
+        };
+        const leaseProviders = new Map();
+        for (const hop of parsedRoute.hops) {
+            const channelId = 'channelId' in hop ? hop.channelId : undefined;
+            if (channelId)
+                leaseProviders.set(channelId, context.leaseProvider);
+            if ('inboundChannelId' in hop && hop.inboundChannelId)
+                leaseProviders.set(hop.inboundChannelId, context.leaseProvider);
+            if ('outboundChannelId' in hop && hop.outboundChannelId)
+                leaseProviders.set(hop.outboundChannelId, context.leaseProvider);
+        }
+        return withOperation(context, params, async () => {
+            const result = isCrossToken
+                ? await (0, omnia_router_1.executeCrossTokenPayment)(ops, context.channels, parsedRoute, parsedRequest, leaseProviders)
+                : await (0, omnia_router_1.executeMultiHopPayment)(ops, context.channels, parsedRoute, parsedRequest, leaseProviders);
+            if (!result.success)
+                throw new Error(result.error ?? 'multi-hop payment failed');
+            return {
+                success: true,
+                preimage: result.preimage,
+                settledHops: result.settledHops,
+            };
+        });
     };
-    register('totem_omniaPayMultiHop', unsupported, 'omnia/payMultiHop');
+    register('totem_omniaPayMultiHop', payMultiHop, 'omnia/payMultiHop');
     return methods;
 }

package/dist/cli.js

@@ -1,8 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = require("./index.js");
+const signing_js_1 = require("./signing.js");
+const identity_js_1 = require("./identity.js");
 async function main() {
-    const host = (0, index_js_1.createOmniaHost)((0, index_js_1.loadConfigFromEnv)());
+    const config = (0, index_js_1.loadConfigFromEnv)();
+    const signing = config.readOnly || !(0, signing_js_1.hasSigningMaterial)(config)
+        ? undefined
+        : (0, signing_js_1.createHostSigning)(config);
+    const identityAndManifest = signing
+        ? await (0, identity_js_1.createHostIdentityAndManifest)(config, signing)
+        : undefined;
+    const host = (0, index_js_1.createOmniaHost)(config, signing
+        ? {
+            signer: signing.signer,
+            leaseProvider: signing.leaseProvider,
+            identity: identityAndManifest?.identity
+                ? {
+                    address: signing.address,
+                    publicKeyDigest: signing.publicKeyDigest,
+                    identityId: identityAndManifest.identity.document.id,
+                    delegation: identityAndManifest.identity.delegation,
+                }
+                : { address: signing.address, publicKeyDigest: signing.publicKeyDigest },
+            manifest: identityAndManifest?.manifest,
+        }
+        : {});
     let closing = false;
     let resolveStopped;
     const stopped = new Promise((resolve) => {

package/dist/config.d.ts

@@ -12,6 +12,20 @@ export interface OmniaHostConfig {
     localSettlementAddress?: string;
     nodeMode?: string;
     wsPath: string;
+    /** BIP39 mnemonic or hex seed (same formats @totemsdk/core accepts). */
+    seed?: string;
+    /** Path to a keyfile JSON (resolved against cwd). */
+    keyfile?: string;
+    /** Keyfile decryption passphrase. */
+    keyfilePassphrase?: string;
+    /** Stable device id for the lease journal. */
+    deviceId?: string;
+    /** "1" forces read-only mode even with keys present. */
+    readOnly: boolean;
+    /** Identity file containing a delegated identity claim (operator root → service delegate). */
+    identityFile?: string;
+    /** EdgeServiceManifest serviceType (default "omnia-router"). */
+    serviceType: string;
 }
 /** Load the daemon configuration from the documented OMNIA_* environment. */
 export declare function loadConfigFromEnv(env?: NodeJS.ProcessEnv): OmniaHostConfig;

package/dist/config.js

@@ -28,9 +28,33 @@ function optionalInteger(value) {
         throw new Error(`OMNIA_LOCAL_ADDRESS_INDEX must be a non-negative integer; received ${value}`);
     return parsed;
 }
+function parseSeed(value) {
+    const seed = optional(value);
+    if (!seed)
+        return undefined;
+    const words = seed.trim().split(/\s+/);
+    const looksLikeMnemonic = words.length >= 12 && words.every((word) => /^[a-zA-Z]+$/.test(word));
+    const looksLikeHex = /^(0x)?[0-9a-fA-F]+$/.test(seed.trim());
+    if (!looksLikeMnemonic && !looksLikeHex) {
+        throw new Error('OMNIA_HOST_SEED must be a BIP39 mnemonic (12+ words) or a hex seed (e.g. 0x…64 hex chars); ' +
+            'received a value that is neither');
+    }
+    if (looksLikeHex) {
+        const raw = seed.trim().replace(/^0x/i, '');
+        if (raw.length !== 64) {
+            throw new Error(`OMNIA_HOST_SEED hex form must be exactly 32 bytes (64 hex chars); received ${raw.length} hex chars`);
+        }
+    }
+    return seed;
+}
 /** Load the daemon configuration from the documented OMNIA_* environment. */
 function loadConfigFromEnv(env = process.env) {
     const dataRoot = node_path_1.default.join(node_os_1.default.homedir(), '.totem', 'omnia');
+    const seed = parseSeed(env.OMNIA_HOST_SEED);
+    const keyfile = optional(env.OMNIA_HOST_KEYFILE);
+    if (seed && keyfile) {
+        throw new Error('OMNIA_HOST_SEED and OMNIA_HOST_KEYFILE are mutually exclusive — set exactly one of them');
+    }
     return {
         port: parsePort(env.OMNIA_HOST_PORT),
         host: env.OMNIA_HOST_BIND?.trim() || '127.0.0.1',
@@ -45,5 +69,12 @@ function loadConfigFromEnv(env = process.env) {
         localSettlementAddress: optional(env.OMNIA_LOCAL_SETTLEMENT_ADDRESS),
         nodeMode: optional(env.OMNIA_NODE_MODE),
         wsPath: env.OMNIA_WS_PATH?.trim() || '/rpc',
+        seed,
+        keyfile,
+        keyfilePassphrase: optional(env.OMNIA_HOST_KEYFILE_PASSPHRASE),
+        deviceId: optional(env.OMNIA_HOST_DEVICE_ID),
+        readOnly: env.OMNIA_HOST_READ_ONLY?.trim() === '1',
+        identityFile: optional(env.OMNIA_HOST_IDENTITY_FILE),
+        serviceType: optional(env.OMNIA_HOST_SERVICE_TYPE) ?? 'omnia-router',
     };
 }

package/dist/identity.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Host identity + manifest layer (opt-in).
+ *
+ * - Service identity: an identity document derived from the host seed, plus an
+ *   optional delegated identity claim loaded from OMNIA_HOST_IDENTITY_FILE
+ *   (operator root → service delegate), validated via verifyIdentityClaim.
+ * - Manifest: an EdgeServiceManifest signed at boot with the same signing path
+ *   (signManifest). No periodic re-signing.
+ *
+ * Channels remain authenticated purely by WOTS signatures — identity is a
+ * host-layer, opt-in concern and never touches @totemsdk/omnia.
+ */
+import { type SignedIdentityClaim, type TotemIdentityDocument } from '@totemsdk/identity';
+import { type EdgeServiceManifest, type SignedManifest } from '@totemsdk/manifest';
+import type { OmniaHostConfig } from './config.js';
+import type { HostSigning } from './signing.js';
+export interface HostIdentity {
+    document: TotemIdentityDocument;
+    delegation?: SignedIdentityClaim;
+}
+export interface HostIdentityAndManifest {
+    identity?: HostIdentity;
+    manifest: SignedManifest<EdgeServiceManifest>;
+}
+/** Load and validate the delegated identity claim file (if configured). */
+export declare function loadHostIdentity(config: OmniaHostConfig, signing: HostSigning): HostIdentity | undefined;
+/** Sign the boot-time EdgeServiceManifest with the host signing path. */
+export declare function createHostManifest(config: OmniaHostConfig, signing: HostSigning, identity?: HostIdentity): Promise<SignedManifest<EdgeServiceManifest>>;
+/** Boot-time identity + manifest assembly. */
+export declare function createHostIdentityAndManifest(config: OmniaHostConfig, signing: HostSigning): Promise<HostIdentityAndManifest>;

package/dist/identity.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Host identity + manifest layer (opt-in).
+ *
+ * - Service identity: an identity document derived from the host seed, plus an
+ *   optional delegated identity claim loaded from OMNIA_HOST_IDENTITY_FILE
+ *   (operator root → service delegate), validated via verifyIdentityClaim.
+ * - Manifest: an EdgeServiceManifest signed at boot with the same signing path
+ *   (signManifest). No periodic re-signing.
+ *
+ * Channels remain authenticated purely by WOTS signatures — identity is a
+ * host-layer, opt-in concern and never touches @totemsdk/omnia.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadHostIdentity = loadHostIdentity;
+exports.createHostManifest = createHostManifest;
+exports.createHostIdentityAndManifest = createHostIdentityAndManifest;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const identity_1 = require("@totemsdk/identity");
+const manifest_1 = require("@totemsdk/manifest");
+function isEdgeServiceType(value) {
+    return [
+        'sensor',
+        'robot',
+        'mqtt-feed',
+        'proof-index',
+        'lookup-provider',
+        'omnia-router',
+        'calibration-authority',
+        'verifier',
+        'machine-service',
+        'other',
+    ].includes(value);
+}
+/** Load and validate the delegated identity claim file (if configured). */
+function loadHostIdentity(config, signing) {
+    const document = (0, identity_1.createIdentityDocument)({
+        kind: 'service',
+        rootAddress: signing.address,
+        controllerAddress: signing.address,
+        metadata: {
+            serviceType: config.serviceType,
+            publicKeyDigest: signing.publicKeyDigest,
+        },
+    });
+    if (!config.identityFile) {
+        return { document };
+    }
+    const identityPath = node_path_1.default.resolve(process.cwd(), config.identityFile);
+    let raw;
+    try {
+        raw = node_fs_1.default.readFileSync(identityPath, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`OMNIA_HOST_IDENTITY_FILE could not be read at ${identityPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let delegation;
+    try {
+        delegation = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`OMNIA_HOST_IDENTITY_FILE at ${identityPath} is not valid JSON`);
+    }
+    const result = (0, identity_1.verifyIdentityClaim)(delegation);
+    if (!result.valid) {
+        throw new Error(`OMNIA_HOST_IDENTITY_FILE delegation failed verification: ${result.reason ?? 'invalid claim'}`);
+    }
+    if (delegation.claim.type !== 'delegates_to') {
+        throw new Error('OMNIA_HOST_IDENTITY_FILE must contain a delegates_to claim');
+    }
+    if (delegation.claim.object !== signing.address) {
+        throw new Error(`OMNIA_HOST_IDENTITY_FILE delegates to ${delegation.claim.object}, but the host address is ${signing.address}`);
+    }
+    return { document, delegation };
+}
+/** Sign the boot-time EdgeServiceManifest with the host signing path. */
+async function createHostManifest(config, signing, identity) {
+    const serviceType = isEdgeServiceType(config.serviceType) ? config.serviceType : 'other';
+    const manifest = {
+        type: 'edge-service',
+        serviceId: `omnia-host:${signing.publicKeyDigest}`,
+        name: 'omnia-host',
+        version: '0.1.1',
+        operatorAddress: identity?.delegation?.claim.issuer ?? signing.address,
+        serviceType,
+        description: 'Durable Omnia node daemon for channel lifecycle, routing, and control APIs',
+        endpoints: [{ type: 'websocket', uri: `ws://${config.host}:${config.port}${config.wsPath}` }],
+        capabilities: ['omnia:open-channel', 'omnia:update-channel', 'omnia:route', 'omnia:settle'],
+        tags: ['omnia', 'payment-channel', 'daemon'],
+    };
+    return (0, manifest_1.signManifest)(manifest, signing.perAddressSeed, 0);
+}
+/** Boot-time identity + manifest assembly. */
+async function createHostIdentityAndManifest(config, signing) {
+    const identity = loadHostIdentity(config, signing);
+    const manifest = await createHostManifest(config, signing, identity);
+    return { identity, manifest };
+}

package/dist/index.d.ts

@@ -2,6 +2,10 @@ export type { OmniaHostConfig } from './config.js';
 export { loadConfigFromEnv } from './config.js';
 export type { OmniaHost } from './lifecycle.js';
 export { createOmniaHost } from './lifecycle.js';
+export type { HostSigning } from './signing.js';
+export { createHostSigning, hasSigningMaterial, JsonFileStorageAdapter, leaseStorageDir, encryptSeedForKeyfile, } from './signing.js';
+export type { HostIdentity, HostIdentityAndManifest } from './identity.js';
+export { createHostIdentityAndManifest, createHostManifest, loadHostIdentity, } from './identity.js';
 export { SqliteChannelStore } from './stores/sqlite-store.js';
 export { OperationStore } from './stores/operations.js';
 export type { OperationRecord, OperationStatus } from './stores/operations.js';

package/dist/index.js

@@ -1,10 +1,20 @@
 "use strict";
 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.createOmniaHost = exports.loadConfigFromEnv = void 0;
+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");
 Object.defineProperty(exports, "createOmniaHost", { enumerable: true, get: function () { return lifecycle_js_1.createOmniaHost; } });
+var signing_js_1 = require("./signing.js");
+Object.defineProperty(exports, "createHostSigning", { enumerable: true, get: function () { return signing_js_1.createHostSigning; } });
+Object.defineProperty(exports, "hasSigningMaterial", { enumerable: true, get: function () { return signing_js_1.hasSigningMaterial; } });
+Object.defineProperty(exports, "JsonFileStorageAdapter", { enumerable: true, get: function () { return signing_js_1.JsonFileStorageAdapter; } });
+Object.defineProperty(exports, "leaseStorageDir", { enumerable: true, get: function () { return signing_js_1.leaseStorageDir; } });
+Object.defineProperty(exports, "encryptSeedForKeyfile", { enumerable: true, get: function () { return signing_js_1.encryptSeedForKeyfile; } });
+var identity_js_1 = require("./identity.js");
+Object.defineProperty(exports, "createHostIdentityAndManifest", { enumerable: true, get: function () { return identity_js_1.createHostIdentityAndManifest; } });
+Object.defineProperty(exports, "createHostManifest", { enumerable: true, get: function () { return identity_js_1.createHostManifest; } });
+Object.defineProperty(exports, "loadHostIdentity", { enumerable: true, get: function () { return identity_js_1.loadHostIdentity; } });
 var sqlite_store_js_1 = require("./stores/sqlite-store.js");
 Object.defineProperty(exports, "SqliteChannelStore", { enumerable: true, get: function () { return sqlite_store_js_1.SqliteChannelStore; } });
 var operations_js_1 = require("./stores/operations.js");

package/dist/lifecycle.d.ts

@@ -29,6 +29,15 @@ export interface OmniaHostDependencies {
     spliceProposals?: Map<string, SpliceProposal>;
     spliceAcceptances?: Map<string, SpliceAcceptance>;
     spliceLeaseProvider?: SpliceLeaseProvider;
+    /** Opt-in host identity surface (whoami). */
+    identity?: {
+        address: string;
+        publicKeyDigest: string;
+        identityId?: string;
+        delegation?: unknown;
+    };
+    /** Boot-time signed EdgeServiceManifest (getManifest). */
+    manifest?: unknown;
 }
 export interface OmniaHost {
     readonly config: OmniaHostConfig;

package/dist/lifecycle.js

@@ -77,6 +77,10 @@ function createOmniaHost(config, dependencies = {}) {
                 chainProvider: dependencies.chainProvider ?? chainAdapter,
             });
             if (!controlServer) {
+                const readOnly = !dependencies.signer || !dependencies.leaseProvider;
+                if (readOnly) {
+                    console.log('[omnia-host] no signing material; starting READ-ONLY');
+                }
                 controlServer = (0, jsonrpc_js_1.createControlServer)({
                     host: config.host,
                     port: config.port,
@@ -96,6 +100,9 @@ function createOmniaHost(config, dependencies = {}) {
                         spliceProposals: dependencies.spliceProposals,
                         spliceAcceptances: dependencies.spliceAcceptances,
                         spliceLeaseProvider: dependencies.spliceLeaseProvider,
+                        readOnly,
+                        identity: dependencies.identity,
+                        manifest: dependencies.manifest,
                         refreshRouting: () => routingProvider.rebuild((0, routing_provider_js_1.channelGraphEdges)(channelStore.values())),
                     }),
                 });

package/dist/signing.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Host signing material — derives the channel signer, WOTS lease provider,
+ * and Minima address from env-provisioned key material.
+ *
+ * Key model (matches @totemsdk/omnia's verification path):
+ *   - `baseSeed` comes from OMNIA_HOST_SEED (BIP39 mnemonic or 32-byte hex)
+ *     or from an OMNIA_HOST_KEYFILE JSON.
+ *   - `perAddressSeed = derivePerAddressSeed(baseSeed, localAddressIndex)`.
+ *   - The channel participant's `publicKeyDigest` is the flat WOTS PK digest
+ *     `derivePKdigest(perAddressSeed, 0)` — omnia verifies signatures with
+ *     `wotsVerifyDigest(sig, digest, pkDigest)`, which is key-index agnostic,
+ *     so the signer always signs with key index 0 of the per-address seed.
+ *   - The lease indices {addressIndex, l1, l2} are slot bookkeeping for
+ *     double-sign prevention (watermark monotonicity), not key derivation.
+ *
+ * The lease journal/watermark persist in a directory next to the channel DB
+ * (`<dbPath>.lease/`) so they survive restarts together with the channel store.
+ */
+import type { StorageAdapter } from '@totemsdk/core';
+import type { ChannelSigner } from '@totemsdk/omnia';
+import type { WotsLeaseProvider } from '@totemsdk/wots-lease';
+import type { OmniaHostConfig } from './config.js';
+export interface HostSigning {
+    signer: ChannelSigner;
+    leaseProvider: WotsLeaseProvider;
+    address: string;
+    publicKeyDigest: string;
+    /** 32-byte base seed (used by the identity/manifest layer). */
+    baseSeed: Uint8Array;
+    /** Per-address seed used for channel signing (key index 0). */
+    perAddressSeed: Uint8Array;
+    addressIndex: number;
+    deviceId: string;
+}
+interface KeyfilePayload {
+    seed: string;
+    encrypted?: boolean;
+    salt?: string;
+    iv?: string;
+    authTag?: string;
+}
+/** Encrypt a 32-byte seed into a keyfile payload (used by tooling/tests). */
+export declare function encryptSeedForKeyfile(seed: Uint8Array, passphrase: string): KeyfilePayload;
+/**
+ * JSON-file-backed StorageAdapter rooted at a directory next to the channel DB.
+ * Each key is stored as `<key>.json`; the directory is created on first write.
+ */
+export declare class JsonFileStorageAdapter implements StorageAdapter {
+    private readonly dir;
+    constructor(dir: string);
+    private fileFor;
+    private ensureDir;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    has(key: string): Promise<boolean>;
+}
+/** Directory holding the lease journal/watermark next to the channel DB. */
+export declare function leaseStorageDir(dbPath: string): string;
+/**
+ * Derive the host's signing stack from config.
+ *
+ * Throws when no key material is configured. Callers gate this behind
+ * `config.readOnly` / key presence checks.
+ */
+export declare function createHostSigning(config: OmniaHostConfig): HostSigning;
+/** True when the config carries signing material (seed or keyfile). */
+export declare function hasSigningMaterial(config: OmniaHostConfig): boolean;
+export {};

package/dist/signing.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * Host signing material — derives the channel signer, WOTS lease provider,
+ * and Minima address from env-provisioned key material.
+ *
+ * Key model (matches @totemsdk/omnia's verification path):
+ *   - `baseSeed` comes from OMNIA_HOST_SEED (BIP39 mnemonic or 32-byte hex)
+ *     or from an OMNIA_HOST_KEYFILE JSON.
+ *   - `perAddressSeed = derivePerAddressSeed(baseSeed, localAddressIndex)`.
+ *   - The channel participant's `publicKeyDigest` is the flat WOTS PK digest
+ *     `derivePKdigest(perAddressSeed, 0)` — omnia verifies signatures with
+ *     `wotsVerifyDigest(sig, digest, pkDigest)`, which is key-index agnostic,
+ *     so the signer always signs with key index 0 of the per-address seed.
+ *   - The lease indices {addressIndex, l1, l2} are slot bookkeeping for
+ *     double-sign prevention (watermark monotonicity), not key derivation.
+ *
+ * The lease journal/watermark persist in a directory next to the channel DB
+ * (`<dbPath>.lease/`) so they survive restarts together with the channel store.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFileStorageAdapter = void 0;
+exports.encryptSeedForKeyfile = encryptSeedForKeyfile;
+exports.leaseStorageDir = leaseStorageDir;
+exports.createHostSigning = createHostSigning;
+exports.hasSigningMaterial = hasSigningMaterial;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const core_1 = require("@totemsdk/core");
+const wots_lease_1 = require("@totemsdk/wots-lease");
+const wots_lease_2 = require("@totemsdk/wots-lease");
+const KEYFILE_SCRYPT_N = 16384;
+const KEYFILE_SCRYPT_R = 8;
+const KEYFILE_SCRYPT_P = 1;
+const KEYFILE_KEY_LEN = 32;
+function decryptSeed(payload, passphrase) {
+    if (!payload.encrypted) {
+        return (0, core_1.hexToBytes)(payload.seed);
+    }
+    if (!passphrase) {
+        throw new Error('OMNIA_HOST_KEYFILE is encrypted — OMNIA_HOST_KEYFILE_PASSPHRASE is required');
+    }
+    if (!payload.salt || !payload.iv || !payload.authTag) {
+        throw new Error('OMNIA_HOST_KEYFILE is marked encrypted but is missing salt/iv/authTag');
+    }
+    const key = (0, node_crypto_1.scryptSync)(passphrase, Buffer.from(payload.salt, 'hex'), KEYFILE_KEY_LEN, {
+        N: KEYFILE_SCRYPT_N,
+        r: KEYFILE_SCRYPT_R,
+        p: KEYFILE_SCRYPT_P,
+    });
+    const decipher = (0, node_crypto_1.createDecipheriv)('aes-256-gcm', key, Buffer.from(payload.iv, 'hex'));
+    decipher.setAuthTag(Buffer.from(payload.authTag, 'hex'));
+    const plain = Buffer.concat([
+        decipher.update(Buffer.from(payload.seed, 'hex')),
+        decipher.final(),
+    ]);
+    return new Uint8Array(plain);
+}
+/** Encrypt a 32-byte seed into a keyfile payload (used by tooling/tests). */
+function encryptSeedForKeyfile(seed, passphrase) {
+    const salt = (0, node_crypto_1.randomBytes)(16);
+    const iv = (0, node_crypto_1.randomBytes)(12);
+    const key = (0, node_crypto_1.scryptSync)(passphrase, salt, KEYFILE_KEY_LEN, {
+        N: KEYFILE_SCRYPT_N,
+        r: KEYFILE_SCRYPT_R,
+        p: KEYFILE_SCRYPT_P,
+    });
+    const cipher = (0, node_crypto_1.createCipheriv)('aes-256-gcm', key, iv);
+    const encrypted = Buffer.concat([cipher.update(seed), cipher.final()]);
+    return {
+        seed: encrypted.toString('hex'),
+        encrypted: true,
+        salt: salt.toString('hex'),
+        iv: iv.toString('hex'),
+        authTag: cipher.getAuthTag().toString('hex'),
+    };
+}
+function resolveBaseSeed(config) {
+    if (config.seed) {
+        const trimmed = config.seed.trim();
+        if (/^(0x)?[0-9a-fA-F]+$/.test(trimmed)) {
+            return (0, core_1.hexToBytes)(trimmed);
+        }
+        return (0, core_1.phraseToSeed)(trimmed);
+    }
+    if (config.keyfile) {
+        const keyfilePath = node_path_1.default.resolve(process.cwd(), config.keyfile);
+        let raw;
+        try {
+            raw = node_fs_1.default.readFileSync(keyfilePath, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`OMNIA_HOST_KEYFILE could not be read at ${keyfilePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        let payload;
+        try {
+            payload = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`OMNIA_HOST_KEYFILE at ${keyfilePath} is not valid JSON`);
+        }
+        if (typeof payload.seed !== 'string' || payload.seed.length === 0) {
+            throw new Error(`OMNIA_HOST_KEYFILE at ${keyfilePath} is missing a "seed" field`);
+        }
+        const seed = decryptSeed(payload, config.keyfilePassphrase);
+        if (seed.length !== 32) {
+            throw new Error(`OMNIA_HOST_KEYFILE seed must be 32 bytes; got ${seed.length}`);
+        }
+        return seed;
+    }
+    throw new Error('createHostSigning requires OMNIA_HOST_SEED or OMNIA_HOST_KEYFILE');
+}
+/**
+ * JSON-file-backed StorageAdapter rooted at a directory next to the channel DB.
+ * Each key is stored as `<key>.json`; the directory is created on first write.
+ */
+class JsonFileStorageAdapter {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    fileFor(key) {
+        const safe = key.replace(/[^a-zA-Z0-9_-]/g, '_');
+        return node_path_1.default.join(this.dir, `${safe}.json`);
+    }
+    ensureDir() {
+        node_fs_1.default.mkdirSync(this.dir, { recursive: true });
+    }
+    async get(key) {
+        const file = this.fileFor(key);
+        if (!node_fs_1.default.existsSync(file))
+            return null;
+        try {
+            return JSON.parse(node_fs_1.default.readFileSync(file, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    async set(key, value) {
+        this.ensureDir();
+        node_fs_1.default.writeFileSync(this.fileFor(key), JSON.stringify(value));
+    }
+    async remove(key) {
+        const file = this.fileFor(key);
+        if (!node_fs_1.default.existsSync(file))
+            return false;
+        node_fs_1.default.unlinkSync(file);
+        return true;
+    }
+    async clear() {
+        if (!node_fs_1.default.existsSync(this.dir))
+            return;
+        for (const entry of node_fs_1.default.readdirSync(this.dir)) {
+            node_fs_1.default.unlinkSync(node_path_1.default.join(this.dir, entry));
+        }
+    }
+    async keys() {
+        if (!node_fs_1.default.existsSync(this.dir))
+            return [];
+        return node_fs_1.default.readdirSync(this.dir)
+            .filter((name) => name.endsWith('.json'))
+            .map((name) => name.slice(0, -'.json'.length));
+    }
+    async has(key) {
+        return node_fs_1.default.existsSync(this.fileFor(key));
+    }
+}
+exports.JsonFileStorageAdapter = JsonFileStorageAdapter;
+/** Directory holding the lease journal/watermark next to the channel DB. */
+function leaseStorageDir(dbPath) {
+    return `${dbPath}.lease`;
+}
+/** Extract the numeric slot from a `device-N` id, or undefined. */
+function parseDeviceSlot(deviceId) {
+    const match = /^device-?(\d+)$/i.exec(deviceId);
+    return match ? parseInt(match[1], 10) : undefined;
+}
+/**
+ * Derive the host's signing stack from config.
+ *
+ * Throws when no key material is configured. Callers gate this behind
+ * `config.readOnly` / key presence checks.
+ */
+function createHostSigning(config) {
+    const baseSeed = resolveBaseSeed(config);
+    const addressIndex = config.localAddressIndex ?? 0;
+    const pinnedSlot = config.deviceId ? parseDeviceSlot(config.deviceId) : undefined;
+    const deviceSlot = pinnedSlot ?? (0, wots_lease_2.deviceSlotForAddressIndex)(addressIndex);
+    const deviceId = config.deviceId ?? `device-${deviceSlot}`;
+    const range = (0, wots_lease_2.allocateDeviceRange)({ deviceSlot, deviceId });
+    if (addressIndex < range.startAddressIndex || addressIndex > range.endAddressIndex) {
+        throw new Error(`localAddressIndex ${addressIndex} is outside device slot ${deviceSlot} range ` +
+            `${range.startAddressIndex}–${range.endAddressIndex}`);
+    }
+    const perAddressSeed = (0, core_1.derivePerAddressSeed)(baseSeed, addressIndex);
+    const kp = (0, core_1.wotsKeypairFromSeed)(perAddressSeed, 0);
+    const publicKeyDigest = `0x${(0, core_1.bytesToHex)(kp.pk)}`;
+    const address = (0, core_1.wotsAddressFromKeypair)(kp);
+    const signer = {
+        publicKeyDigest,
+        async sign(payload, _indices) {
+            return (0, core_1.wotsSign)(perAddressSeed, 0, payload);
+        },
+    };
+    const storage = new JsonFileStorageAdapter(leaseStorageDir(config.dbPath));
+    const leaseProvider = new wots_lease_1.LocalLeaseProvider(storage, undefined, deviceId);
+    return {
+        signer,
+        leaseProvider,
+        address,
+        publicKeyDigest,
+        baseSeed,
+        perAddressSeed,
+        addressIndex,
+        deviceId,
+    };
+}
+/** True when the config carries signing material (seed or keyfile). */
+function hasSigningMaterial(config) {
+    return Boolean(config.seed || config.keyfile);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/omnia-host",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Durable Omnia node daemon for channel lifecycle, routing, and control APIs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,14 +22,17 @@
   "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/chain-provider": "^0.1.6",
+    "@totemsdk/core": "^1.2.9",
+    "@totemsdk/identity": "^0.1.4",
+    "@totemsdk/manifest": "^0.1.3",
+    "@totemsdk/omnia": "^1.0.0",
+    "@totemsdk/omnia-factory": "^0.1.9",
     "@totemsdk/omnia-router": "^0.1.5",
-    "@totemsdk/omnia-vtxo": "^0.1.0",
+    "@totemsdk/omnia-splice": "^0.1.8",
+    "@totemsdk/omnia-vtxo": "^0.1.1",
     "@totemsdk/minima-rpc": "^0.1.4",
-    "@totemsdk/wots-lease": "^0.1.5",
-    "@totemsdk/omnia-splice": "^0.1.7"
+    "@totemsdk/wots-lease": "^1.0.0"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
@@ -38,7 +41,8 @@
     "@types/ws": "^8.5.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11",
-    "typescript": "5.9.3"
+    "typescript": "5.9.3",
+    "@totemsdk/txpow": "^0.1.7"
   },
   "engines": {
     "node": ">=20.0.0"
@@ -51,7 +55,7 @@
   "homepage": "https://totem.ing",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/totem-sdk/totem-sdk.git",
+    "url": "git+https://github.com/Totem-Edge/totem-sdk.git",
     "directory": "packages/omnia-host"
   },
   "bugs": {