@totemsdk/omnia-host 0.1.0

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTotemNodeAdapter = createTotemNodeAdapter;
+const chain_provider_1 = require("@totemsdk/chain-provider");
+const minima_rpc_1 = require("@totemsdk/minima-rpc");
+function createTotemNodeAdapter(options) {
+    const client = options.client ?? (0, minima_rpc_1.createMinimaRpcClient)({
+        host: options.host,
+        port: options.port,
+        password: options.password,
+        ssl: options.ssl ?? false,
+    });
+    const provider = options.provider ?? new chain_provider_1.MinimaRpcProvider(client);
+    const listeners = new Set();
+    const pollIntervalMs = options.pollIntervalMs ?? 5_000;
+    let timer;
+    let stopped = false;
+    async function poll() {
+        if (stopped || listeners.size === 0)
+            return;
+        try {
+            const tip = await provider.getTip();
+            for (const listener of listeners)
+                listener(tip);
+        }
+        finally {
+            if (!stopped && listeners.size > 0)
+                timer = setTimeout(() => void poll(), pollIntervalMs);
+        }
+    }
+    return {
+        getCoins: (query) => provider.getCoins(query),
+        getCoin: (coinId) => provider.getCoin(coinId),
+        getProof: (coinId) => provider.getProof(coinId),
+        getTip: () => provider.getTip(),
+        getToken: (tokenId) => provider.getToken(tokenId),
+        searchTokens: (query) => provider.searchTokens(query),
+        getTokensByCreator: (address) => provider.getTokensByCreator(address),
+        broadcastTxPoW: (txpowHex) => provider.broadcastTxPoW(txpowHex),
+        async getMode() {
+            const result = await client.runCommand('getmode');
+            if (!result || typeof result !== 'object')
+                return undefined;
+            const mode = result.mode;
+            return typeof mode === 'string' ? mode : undefined;
+        },
+        async waitForConfirmation(coinId, confirmationOptions = {}) {
+            const timeoutMs = confirmationOptions.timeoutMs ?? 120_000;
+            const interval = confirmationOptions.pollIntervalMs ?? pollIntervalMs;
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() < deadline) {
+                const coin = await provider.getCoin(coinId);
+                if (coin && !coin.spent)
+                    return;
+                await new Promise((resolve) => setTimeout(resolve, interval));
+            }
+            throw new Error(`Timed out waiting for coin confirmation: ${coinId}`);
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            if (listeners.size === 1)
+                void poll();
+            return () => {
+                listeners.delete(listener);
+                if (listeners.size === 0 && timer) {
+                    clearTimeout(timer);
+                    timer = undefined;
+                }
+            };
+        },
+        close() {
+            stopped = true;
+            listeners.clear();
+            if (timer)
+                clearTimeout(timer);
+        },
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./index.js");
+async function main() {
+    const host = (0, index_js_1.createOmniaHost)((0, index_js_1.loadConfigFromEnv)());
+    let closing = false;
+    let resolveStopped;
+    const stopped = new Promise((resolve) => {
+        resolveStopped = resolve;
+    });
+    const shutdown = async (signal) => {
+        if (closing)
+            return;
+        closing = true;
+        console.log(`[omnia-host] Received ${signal}; shutting down`);
+        try {
+            await host.close();
+        }
+        finally {
+            resolveStopped();
+        }
+    };
+    process.once('SIGINT', () => { void shutdown('SIGINT'); });
+    process.once('SIGTERM', () => { void shutdown('SIGTERM'); });
+    await host.start();
+    console.log(`[omnia-host] Starting on port ${host.config.port}`);
+    await stopped;
+}
+main().catch((err) => {
+    console.error('[omnia-host] Fatal startup error:', err);
+    process.exitCode = 1;
+});

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+export interface OmniaHostConfig {
+    port: number;
+    host: string;
+    dbPath: string;
+    chainRpcUrl: string;
+    chainRpcPassword?: string;
+    analyticsDbPath?: string;
+    relay?: string;
+    localPubkey?: string;
+    localPartyId?: string;
+    localAddressIndex?: number;
+    localSettlementAddress?: string;
+    nodeMode?: string;
+    wsPath: string;
+}
+/** Load the daemon configuration from the documented OMNIA_* environment. */
+export declare function loadConfigFromEnv(env?: NodeJS.ProcessEnv): OmniaHostConfig;

package/dist/config.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfigFromEnv = loadConfigFromEnv;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+function parsePort(value) {
+    if (!value)
+        return 50052;
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`OMNIA_HOST_PORT must be an integer between 1 and 65535; received ${value}`);
+    }
+    return port;
+}
+function optional(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function optionalInteger(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return undefined;
+    const parsed = Number(trimmed);
+    if (!Number.isInteger(parsed) || parsed < 0)
+        throw new Error(`OMNIA_LOCAL_ADDRESS_INDEX must be a non-negative integer; received ${value}`);
+    return parsed;
+}
+/** 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');
+    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'),
+        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),
+        relay: optional(env.OMNIA_RELAY),
+        localPubkey: optional(env.OMNIA_LOCAL_PUBKEY),
+        localPartyId: optional(env.OMNIA_LOCAL_PARTY_ID),
+        localAddressIndex: optionalInteger(env.OMNIA_LOCAL_ADDRESS_INDEX),
+        localSettlementAddress: optional(env.OMNIA_LOCAL_SETTLEMENT_ADDRESS),
+        nodeMode: optional(env.OMNIA_NODE_MODE),
+        wsPath: env.OMNIA_WS_PATH?.trim() || '/rpc',
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export type { OmniaHostConfig } from './config.js';
+export { loadConfigFromEnv } from './config.js';
+export type { OmniaHost } from './lifecycle.js';
+export { createOmniaHost } from './lifecycle.js';
+export { SqliteChannelStore } from './stores/sqlite-store.js';
+export { OperationStore } from './stores/operations.js';
+export type { OperationRecord, OperationStatus } from './stores/operations.js';
+export { createTotemNodeAdapter } from './chain/totem-node-adapter.js';
+export type { TotemNodeAdapter, TotemNodeAdapterOptions, ConfirmationOptions } from './chain/totem-node-adapter.js';
+export { InProcessRoutingProvider } from './router/routing-provider.js';
+export type { RoutingProvider, RouteQuery } from './router/routing-provider.js';
+export { GoRoutingProvider } from './router/go-routing-provider.js';
+export { createHostMethods } from './api/methods.js';
+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';

package/dist/index.js

@@ -0,0 +1,23 @@
+"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;
+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 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");
+Object.defineProperty(exports, "OperationStore", { enumerable: true, get: function () { return operations_js_1.OperationStore; } });
+var totem_node_adapter_js_1 = require("./chain/totem-node-adapter.js");
+Object.defineProperty(exports, "createTotemNodeAdapter", { enumerable: true, get: function () { return totem_node_adapter_js_1.createTotemNodeAdapter; } });
+var routing_provider_js_1 = require("./router/routing-provider.js");
+Object.defineProperty(exports, "InProcessRoutingProvider", { enumerable: true, get: function () { return routing_provider_js_1.InProcessRoutingProvider; } });
+var go_routing_provider_js_1 = require("./router/go-routing-provider.js");
+Object.defineProperty(exports, "GoRoutingProvider", { enumerable: true, get: function () { return go_routing_provider_js_1.GoRoutingProvider; } });
+var methods_js_1 = require("./api/methods.js");
+Object.defineProperty(exports, "createHostMethods", { enumerable: true, get: function () { return methods_js_1.createHostMethods; } });
+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; } });

package/dist/lifecycle.d.ts

@@ -0,0 +1,45 @@
+import type { OmniaHostConfig } from './config.js';
+import type { OmniaSwarm, ChannelSigner, WotsLeaseProviderLike, MinimalChainProvider } from '@totemsdk/omnia';
+import { createOmniaSwarm } from '@totemsdk/omnia';
+import { OperationStore } from './stores/operations.js';
+import type { OmniaChannel } from '@totemsdk/omnia';
+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 OperationStoreLike } from './api/methods.js';
+import type { ChannelFactory, WotsLeaseBundle } from '@totemsdk/omnia-factory';
+import type { SpliceAcceptance, SpliceLeaseProvider, SpliceProposal } from '@totemsdk/omnia-splice';
+export interface OmniaHostDependencies {
+    createSwarm?: (config: Parameters<typeof createOmniaSwarm>[0]) => Promise<OmniaSwarm>;
+    swarm?: OmniaSwarm;
+    channelStore?: Map<string, OmniaChannel>;
+    operationStore?: OperationStore | Pick<OperationStore, 'close'>;
+    signer?: ChannelSigner;
+    leaseProvider?: WotsLeaseProviderLike;
+    chainProvider?: MinimalChainProvider;
+    controlServer?: ControlServer;
+    chainAdapter?: TotemNodeAdapter;
+    routingProvider?: RoutingProvider;
+    methods?: Map<string, JsonRpcHandler>;
+    operationStoreForApi?: OperationStoreLike;
+    localParticipant?: import('@totemsdk/omnia').ChannelParticipant;
+    factories?: Map<string, ChannelFactory>;
+    factoryBundles?: Record<string, WotsLeaseBundle>;
+    spliceProposals?: Map<string, SpliceProposal>;
+    spliceAcceptances?: Map<string, SpliceAcceptance>;
+    spliceLeaseProvider?: SpliceLeaseProvider;
+}
+export interface OmniaHost {
+    readonly config: OmniaHostConfig;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    isStarted(): boolean;
+    readonly swarm?: OmniaSwarm;
+    readonly channels?: Map<string, OmniaChannel>;
+}
+/**
+ * Phase-1 lifecycle shell. Subsystems will be attached in later phases while
+ * preserving idempotent startup and shutdown for the CLI and embedding users.
+ */
+export declare function createOmniaHost(config: OmniaHostConfig, dependencies?: OmniaHostDependencies): OmniaHost;

package/dist/lifecycle.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOmniaHost = createOmniaHost;
+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 methods_js_1 = require("./api/methods.js");
+/**
+ * Phase-1 lifecycle shell. Subsystems will be attached in later phases while
+ * preserving idempotent startup and shutdown for the CLI and embedding users.
+ */
+function createOmniaHost(config, dependencies = {}) {
+    let started = false;
+    let swarm = dependencies.swarm;
+    let unsubscribe;
+    let channelStore = dependencies.channelStore;
+    let ownedStore;
+    let operationStore = dependencies.operationStore && 'get' in dependencies.operationStore
+        ? dependencies.operationStore
+        : undefined;
+    const injectedOperationStore = dependencies.operationStore;
+    let ownedOperationStore;
+    let controlServer = dependencies.controlServer;
+    let chainAdapter = dependencies.chainAdapter;
+    let routingProvider = dependencies.routingProvider ?? new routing_provider_js_1.InProcessRoutingProvider();
+    return {
+        config,
+        get swarm() {
+            return swarm;
+        },
+        get channels() {
+            return channelStore;
+        },
+        async start() {
+            if (started)
+                return;
+            if (!channelStore) {
+                ownedStore = new sqlite_store_js_1.SqliteChannelStore(config.dbPath);
+                channelStore = ownedStore;
+            }
+            if (!operationStore && !injectedOperationStore) {
+                ownedOperationStore = new operations_js_1.OperationStore(config.dbPath);
+                operationStore = ownedOperationStore;
+            }
+            if (!swarm) {
+                const relay = config.relay
+                    ? { mode: 'self-hosted', relayUrl: config.relay }
+                    : { mode: 'native' };
+                swarm = await (dependencies.createSwarm ?? omnia_1.createOmniaSwarm)({
+                    localPubkey: config.localPubkey,
+                    relay,
+                });
+            }
+            if (!chainAdapter) {
+                const rpc = new URL(config.chainRpcUrl);
+                chainAdapter = (0, totem_node_adapter_js_1.createTotemNodeAdapter)({
+                    host: rpc.hostname,
+                    port: Number(rpc.port || (rpc.protocol === 'https:' ? 443 : 80)),
+                    password: config.chainRpcPassword,
+                    ssl: rpc.protocol === 'https:',
+                });
+            }
+            const localParticipant = dependencies.localParticipant ?? (config.localPartyId && config.localPubkey && config.localAddressIndex !== undefined
+                ? {
+                    partyId: config.localPartyId,
+                    publicKeyDigest: config.localPubkey,
+                    addressIndex: config.localAddressIndex,
+                    settlementAddress: config.localSettlementAddress,
+                }
+                : undefined);
+            unsubscribe = (0, omnia_1.createOmniaIntegration)(swarm, channelStore, {
+                signer: dependencies.signer,
+                leaseProvider: dependencies.leaseProvider,
+                chainProvider: dependencies.chainProvider ?? chainAdapter,
+            });
+            if (!controlServer) {
+                controlServer = (0, jsonrpc_js_1.createControlServer)({
+                    host: config.host,
+                    port: config.port,
+                    wsPath: config.wsPath,
+                    isReady: () => started,
+                    methods: dependencies.methods ?? (0, methods_js_1.createHostMethods)({
+                        channels: channelStore,
+                        routing: routingProvider,
+                        operations: dependencies.operationStoreForApi ?? operationStore,
+                        signer: dependencies.signer,
+                        leaseProvider: dependencies.leaseProvider,
+                        chainProvider: dependencies.chainProvider ?? chainAdapter,
+                        swarm,
+                        localParticipant,
+                        factories: dependencies.factories,
+                        factoryBundles: dependencies.factoryBundles,
+                        spliceProposals: dependencies.spliceProposals,
+                        spliceAcceptances: dependencies.spliceAcceptances,
+                        spliceLeaseProvider: dependencies.spliceLeaseProvider,
+                        refreshRouting: () => routingProvider.rebuild((0, routing_provider_js_1.channelGraphEdges)(channelStore.values())),
+                    }),
+                });
+            }
+            try {
+                await controlServer.listen();
+                started = true;
+            }
+            catch (error) {
+                unsubscribe?.();
+                unsubscribe = undefined;
+                chainAdapter?.close();
+                await swarm?.close();
+                if (ownedOperationStore)
+                    await ownedOperationStore.close();
+                ownedOperationStore = undefined;
+                ownedStore?.close();
+                ownedStore = undefined;
+                throw error;
+            }
+        },
+        async close() {
+            if (!started)
+                return;
+            unsubscribe?.();
+            unsubscribe = undefined;
+            await controlServer?.close();
+            chainAdapter?.close();
+            await swarm?.close();
+            if (ownedOperationStore)
+                await ownedOperationStore.close();
+            else if (injectedOperationStore)
+                await injectedOperationStore.close();
+            ownedOperationStore = undefined;
+            ownedStore?.close();
+            ownedStore = undefined;
+            started = false;
+        },
+        isStarted() {
+            return started;
+        },
+    };
+}

package/dist/router/go-routing-provider.d.ts

@@ -0,0 +1,13 @@
+import type { ChannelGraphEdge, CrossTokenRoute, Route } from '@totemsdk/omnia-router';
+import type { RouteQuery, RoutingProvider } from './routing-provider.js';
+/** Optional phase-10 provider for a compiled Go router speaking JSONL over stdio. */
+export declare class GoRoutingProvider implements RoutingProvider {
+    private readonly child;
+    private readonly pending;
+    private nextId;
+    constructor(binaryPath?: string);
+    rebuild(edges: Iterable<ChannelGraphEdge>): void;
+    getRoute(query: RouteQuery): Promise<Route | CrossTokenRoute | null>;
+    close(): void;
+    private call;
+}

package/dist/router/go-routing-provider.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoRoutingProvider = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_readline_1 = require("node:readline");
+/** Optional phase-10 provider for a compiled Go router speaking JSONL over stdio. */
+class GoRoutingProvider {
+    child;
+    pending = new Map();
+    nextId = 1;
+    constructor(binaryPath = 'omnia-router') {
+        this.child = (0, node_child_process_1.spawn)(binaryPath, [], { stdio: ['pipe', 'pipe', 'pipe'] });
+        const lines = (0, node_readline_1.createInterface)({ input: this.child.stdout });
+        lines.on('line', (line) => {
+            try {
+                const response = JSON.parse(line);
+                const pending = response.id === undefined ? undefined : this.pending.get(response.id);
+                if (!pending || response.id === undefined)
+                    return;
+                this.pending.delete(response.id);
+                pending.resolve(response);
+            }
+            catch (error) {
+                for (const pending of this.pending.values())
+                    pending.reject(error);
+                this.pending.clear();
+            }
+        });
+        const fail = (error) => {
+            for (const pending of this.pending.values())
+                pending.reject(error);
+            this.pending.clear();
+        };
+        this.child.once('error', fail);
+        this.child.once('exit', (code) => fail(new Error(`Go router exited with code ${code ?? 'unknown'}`)));
+    }
+    rebuild(edges) {
+        for (const edge of edges) {
+            void this.call('addChannel', edge);
+        }
+    }
+    async getRoute(query) {
+        const response = await this.call('findRoute', {
+            from: query.from,
+            to: query.to,
+            amount: query.amount.toString(),
+            tokenId: query.tokenId,
+            maxHops: query.maxHops,
+        });
+        if (response.error)
+            throw new Error(response.error);
+        return response.result ?? null;
+    }
+    close() {
+        this.child.stdin.end();
+        this.child.kill();
+    }
+    call(method, params) {
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+        });
+    }
+}
+exports.GoRoutingProvider = GoRoutingProvider;

package/dist/router/routing-provider.d.ts

@@ -0,0 +1,21 @@
+import { type ChannelGraphEdge, type CrossTokenRoute, type Route } from '@totemsdk/omnia-router';
+import type { OmniaChannel } from '@totemsdk/omnia';
+export interface RouteQuery {
+    from: string;
+    to: string;
+    amount: bigint;
+    tokenId: string;
+    targetTokenId?: string;
+    maxHops?: number;
+}
+export interface RoutingProvider {
+    rebuild(edges: Iterable<ChannelGraphEdge>): void;
+    getRoute(query: RouteQuery): Route | CrossTokenRoute | null | Promise<Route | CrossTokenRoute | null>;
+}
+export declare function channelGraphEdges(channels: Iterable<OmniaChannel>): ChannelGraphEdge[];
+/** Default in-process TypeScript routing engine. */
+export declare class InProcessRoutingProvider implements RoutingProvider {
+    private graph;
+    rebuild(edges: Iterable<ChannelGraphEdge>): void;
+    getRoute(query: RouteQuery): Route | CrossTokenRoute | null;
+}

package/dist/router/routing-provider.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InProcessRoutingProvider = void 0;
+exports.channelGraphEdges = channelGraphEdges;
+const omnia_router_1 = require("@totemsdk/omnia-router");
+function channelGraphEdges(channels) {
+    const edges = [];
+    for (const channel of channels) {
+        if (channel.status === 'closed')
+            continue;
+        const [first, second] = channel.parties;
+        if (!first || !second)
+            continue;
+        const pending = channel.pendingHTLCs
+            .filter((htlc) => htlc.status === 'pending')
+            .reduce((sum, htlc) => sum + htlc.amount, 0n);
+        const capacity = channel.totalValue > pending ? channel.totalValue - pending : 0n;
+        edges.push({
+            channelId: channel.channelId,
+            from: first.publicKeyDigest,
+            to: second.publicKeyDigest,
+            tokenId: channel.tokenId,
+            availableBalance: channel.balances[first.partyId] ?? 0n,
+            htlcCapacity: capacity,
+            feeRate: 0n,
+        }, {
+            channelId: channel.channelId,
+            from: second.publicKeyDigest,
+            to: first.publicKeyDigest,
+            tokenId: channel.tokenId,
+            availableBalance: channel.balances[second.partyId] ?? 0n,
+            htlcCapacity: capacity,
+            feeRate: 0n,
+        });
+    }
+    return edges;
+}
+/** Default in-process TypeScript routing engine. */
+class InProcessRoutingProvider {
+    graph = (0, omnia_router_1.createChannelGraph)();
+    rebuild(edges) {
+        this.graph = (0, omnia_router_1.createChannelGraph)();
+        for (const edge of edges) {
+            const current = this.graph.edgesByChannel.get(edge.channelId) ?? [];
+            const duplicate = current.findIndex((item) => item.from === edge.from);
+            if (duplicate >= 0)
+                current[duplicate] = edge;
+            else
+                current.push(edge);
+            this.graph.edgesByChannel.set(edge.channelId, current);
+            const nodeEdges = this.graph.nodeEdges.get(edge.from) ?? [];
+            const nodeIndex = nodeEdges.findIndex((item) => item.channelId === edge.channelId && item.from === edge.from);
+            if (nodeIndex >= 0)
+                nodeEdges[nodeIndex] = edge;
+            else
+                nodeEdges.push(edge);
+            this.graph.nodeEdges.set(edge.from, nodeEdges);
+        }
+    }
+    getRoute(query) {
+        if (query.targetTokenId && query.targetTokenId !== query.tokenId) {
+            return (0, omnia_router_1.findCrossTokenRoute)(this.graph, query.from, query.to, query.amount, query.tokenId, query.targetTokenId, { maxHops: query.maxHops });
+        }
+        return (0, omnia_router_1.findRoute)(this.graph, query.from, query.to, query.amount, query.tokenId, { maxHops: query.maxHops });
+    }
+}
+exports.InProcessRoutingProvider = InProcessRoutingProvider;

package/dist/stores/analytics.d.ts

@@ -0,0 +1,36 @@
+export interface AnalyticsEvent {
+    eventId: string;
+    kind: string;
+    occurredAt: number;
+    channelId?: string;
+    operationId?: string;
+    payload: Record<string, unknown>;
+}
+export interface AnalyticsStore {
+    append(event: AnalyticsEvent): Promise<void>;
+    query(kind?: string, limit?: number): Promise<AnalyticsEvent[]>;
+    close(): Promise<void>;
+}
+/**
+ * No-op analytics backend for phase 9 deployments without DuckDB enabled.
+ * The interface keeps analytics off the channel critical path.
+ */
+export declare class DisabledAnalyticsStore implements AnalyticsStore {
+    append(_event: AnalyticsEvent): Promise<void>;
+    query(_kind?: string, _limit?: number): Promise<AnalyticsEvent[]>;
+    close(): Promise<void>;
+}
+/** Adapter boundary for the optional DuckDB implementation. */
+export interface DuckDbConnection {
+    run(sql: string, ...params: unknown[]): Promise<void>;
+    all<T>(sql: string, ...params: unknown[]): Promise<T[]>;
+    close(): Promise<void>;
+}
+export declare class DuckDbAnalyticsStore implements AnalyticsStore {
+    private readonly db;
+    constructor(db: DuckDbConnection);
+    append(event: AnalyticsEvent): Promise<void>;
+    query(kind?: string, limit?: number): Promise<AnalyticsEvent[]>;
+    close(): Promise<void>;
+}
+export declare function initializeDuckDb(db: DuckDbConnection): Promise<void>;