@totemsdk/omnia-host 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Totem SDK Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# @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.
+
+## Run
+
+```bash
+OMNIA_CHAIN_RPC_PASSWORD=secret pnpm --filter @totemsdk/omnia-host build
+OMNIA_CHAIN_RPC_PASSWORD=secret pnpm --filter @totemsdk/omnia-host start
+```
+
+The daemon configuration is read from environment variables:
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `OMNIA_HOST_PORT` | `50052` | Host control and health port |
+| `OMNIA_HOST_DB` | `~/.totem/omnia/omnia.sqlite` | Durable channel database |
+| `OMNIA_CHAIN_RPC` | `http://127.0.0.1:9005` | Totem node RPC endpoint |
+| `OMNIA_CHAIN_RPC_PASSWORD` | unset | Totem node RPC password |
+| `OMNIA_ANALYTICS_DB` | unset | Optional DuckDB analytics path |
+| `OMNIA_RELAY` | native swarm | Optional relay URL |
+| `OMNIA_LOCAL_PUBKEY` | unset | Local Omnia identity |
+| `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 |
+
+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.
+
+The local test environment may skip SQLite integration tests when the
+`better-sqlite3` native addon has not been built. Install lifecycle scripts in
+CI or on the target platform to execute those tests.

package/dist/api/jsonrpc.d.ts

@@ -0,0 +1,33 @@
+import type { AddressInfo } from 'node:net';
+import { type WebSocket } from 'ws';
+export interface JsonRpcRequest {
+    jsonrpc?: '2.0';
+    id?: string | number | null;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export type JsonRpcHandler = (params: unknown) => Promise<unknown> | unknown;
+export interface ControlServerOptions {
+    host: string;
+    port: number;
+    wsPath?: string;
+    isReady?: () => boolean;
+    methods?: Map<string, JsonRpcHandler>;
+    onConnection?: (socket: WebSocket) => void;
+}
+export interface ControlServer {
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    readonly address?: AddressInfo;
+}
+export declare function createControlServer(options: ControlServerOptions): ControlServer;

package/dist/api/jsonrpc.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createControlServer = createControlServer;
+const node_http_1 = __importDefault(require("node:http"));
+const ws_1 = require("ws");
+function response(id, result) {
+    return { jsonrpc: '2.0', id: id ?? null, result };
+}
+function errorResponse(id, code, message) {
+    return { jsonrpc: '2.0', id: id ?? null, error: { code, message } };
+}
+async function dispatch(request, methods) {
+    if (request.jsonrpc !== undefined && request.jsonrpc !== '2.0') {
+        return errorResponse(request.id, -32600, 'Invalid Request');
+    }
+    if (!request.method || typeof request.method !== 'string') {
+        return errorResponse(request.id, -32600, 'Invalid Request');
+    }
+    const method = methods.get(request.method);
+    if (!method)
+        return errorResponse(request.id, -32601, `Method not found: ${request.method}`);
+    try {
+        return response(request.id, await method(request.params));
+    }
+    catch (error) {
+        console.error('[jsonrpc] handler error:', error instanceof Error ? error.stack ?? error.message : String(error));
+        return errorResponse(request.id, -32000, 'Internal error');
+    }
+}
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        if (Buffer.concat(chunks).length > 10 * 1024 * 1024)
+            throw new Error('Request body too large');
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, { 'content-type': 'application/json', 'content-length': Buffer.byteLength(payload) });
+    res.end(payload);
+}
+function createControlServer(options) {
+    const methods = options.methods ?? new Map();
+    const wsPath = options.wsPath ?? '/rpc';
+    const server = node_http_1.default.createServer(async (req, res) => {
+        if (req.method === 'GET' && req.url === '/healthz') {
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/readyz') {
+            const ready = options.isReady?.() ?? false;
+            sendJson(res, ready ? 200 : 503, { ok: ready });
+            return;
+        }
+        if (req.method !== 'POST' || req.url !== wsPath) {
+            sendJson(res, 404, { error: 'Not found' });
+            return;
+        }
+        try {
+            const request = JSON.parse(await readBody(req));
+            sendJson(res, 200, await dispatch(request, methods));
+        }
+        catch (error) {
+            console.error('[jsonrpc] parse error:', error instanceof Error ? error.stack ?? error.message : String(error));
+            sendJson(res, 400, errorResponse(null, -32700, 'Invalid JSON RPC request'));
+        }
+    });
+    const webSockets = new ws_1.WebSocketServer({ noServer: true });
+    server.on('upgrade', (req, socket, head) => {
+        if (req.url !== wsPath) {
+            socket.destroy();
+            return;
+        }
+        webSockets.handleUpgrade(req, socket, head, (ws) => {
+            webSockets.emit('connection', ws, req);
+        });
+    });
+    webSockets.on('connection', (socket) => {
+        options.onConnection?.(socket);
+        socket.on('message', async (data) => {
+            try {
+                const request = JSON.parse(data.toString());
+                socket.send(JSON.stringify(await dispatch(request, methods)));
+            }
+            catch (error) {
+                console.error('[jsonrpc] ws parse error:', error instanceof Error ? error.stack ?? error.message : String(error));
+                socket.send(JSON.stringify(errorResponse(null, -32700, 'Invalid JSON RPC request')));
+            }
+        });
+    });
+    let address;
+    return {
+        get address() { return address; },
+        async listen() {
+            await new Promise((resolve, reject) => {
+                server.once('error', reject);
+                server.listen(options.port, options.host, () => {
+                    server.off('error', reject);
+                    address = server.address();
+                    resolve();
+                });
+            });
+        },
+        async close() {
+            webSockets.close();
+            await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+        },
+    };
+}

package/dist/api/methods.d.ts

@@ -0,0 +1,26 @@
+import type { ChannelParticipant, ChannelSigner, OmniaChannel, OmniaSwarm } from '@totemsdk/omnia';
+import type { ChainStateProvider } from '@totemsdk/chain-provider';
+import type { WotsLeaseProvider } from '@totemsdk/wots-lease';
+import { type ChannelFactory, type WotsLeaseBundle } from '@totemsdk/omnia-factory';
+import { type SpliceAcceptance, type SpliceLeaseProvider, type SpliceProposal } from '@totemsdk/omnia-splice';
+import type { JsonRpcHandler } from './jsonrpc.js';
+import type { RoutingProvider } from '../router/routing-provider.js';
+import type { OperationStore } from '../stores/operations.js';
+export type OperationStoreLike = Pick<OperationStore, 'get' | 'create' | 'transition' | 'listByStatus'>;
+export interface HostApiContext {
+    channels: Map<string, OmniaChannel>;
+    routing: RoutingProvider;
+    refreshRouting?: () => void;
+    operations?: OperationStoreLike;
+    signer?: ChannelSigner;
+    leaseProvider?: WotsLeaseProvider;
+    chainProvider?: ChainStateProvider;
+    swarm?: OmniaSwarm;
+    localParticipant?: ChannelParticipant;
+    factories?: Map<string, ChannelFactory>;
+    factoryBundles?: Record<string, WotsLeaseBundle>;
+    spliceProposals?: Map<string, SpliceProposal>;
+    spliceAcceptances?: Map<string, SpliceAcceptance>;
+    spliceLeaseProvider?: SpliceLeaseProvider;
+}
+export declare function createHostMethods(context: HostApiContext): Map<string, JsonRpcHandler>;

package/dist/api/methods.js

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHostMethods = createHostMethods;
+const omnia_1 = require("@totemsdk/omnia");
+const omnia_factory_1 = require("@totemsdk/omnia-factory");
+const omnia_splice_1 = require("@totemsdk/omnia-splice");
+function channelSummary(channel) {
+    const parties = channel.parties.map((party) => party.partyId);
+    return {
+        channelId: channel.channelId,
+        status: channel.status,
+        tokenId: channel.tokenId,
+        totalValue: channel.totalValue.toString(),
+        localBalance: (channel.balances[parties[0]] ?? 0n).toString(),
+        remoteBalance: (channel.balances[parties[1]] ?? 0n).toString(),
+        currentSequence: channel.currentSequence,
+    };
+}
+function paramsObject(params) {
+    if (!params || typeof params !== 'object' || Array.isArray(params))
+        return {};
+    return params;
+}
+function requiredString(params, key) {
+    const value = params[key];
+    if (typeof value !== 'string' || value.length === 0)
+        throw new Error(`${key} is required`);
+    return value;
+}
+function requiredBigInt(params, key) {
+    const value = requiredString(params, key);
+    try {
+        return BigInt(value);
+    }
+    catch {
+        throw new Error(`${key} must be an integer string`);
+    }
+}
+function operationId(params) {
+    return requiredString(params, 'operationId');
+}
+function bigintRecord(params, key) {
+    const value = params[key];
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${key} must be an object`);
+    return Object.fromEntries(Object.entries(value).map(([partyId, balance]) => [
+        partyId,
+        BigInt(String(balance)),
+    ]));
+}
+function optionalStringRecord(params, key) {
+    const value = params[key];
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${key} must be an object`);
+    return Object.fromEntries(Object.entries(value).map(([name, nested]) => {
+        if (typeof nested !== 'string')
+            throw new Error(`${key}.${name} must be a string`);
+        return [name, nested];
+    }));
+}
+function optionalTransitionInputs(params) {
+    const value = params.inputs;
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('inputs must be an object');
+    return Object.fromEntries(Object.entries(value).map(([name, nested]) => {
+        if (typeof nested === 'string' || typeof nested === 'boolean')
+            return [name, nested];
+        if (typeof nested === 'number' && Number.isSafeInteger(nested))
+            return [name, BigInt(nested)];
+        throw new Error(`inputs.${name} must be a string, boolean, or safe integer`);
+    }));
+}
+function balancesJson(channel) {
+    return Object.fromEntries(Object.entries(channel.balances).map(([partyId, balance]) => [partyId, balance.toString()]));
+}
+async function withOperation(context, params, run) {
+    if (!context.operations)
+        throw new Error('Operation store is not configured');
+    const id = operationId(params);
+    const existing = context.operations.get(id);
+    const verifier = context.operations.verifyRequest;
+    if (existing && verifier && !verifier(id, params)) {
+        throw new Error(`Operation ${id} request does not match the original request`);
+    }
+    if (existing?.status === 'committed')
+        return existing.result;
+    if (existing && !['pending', 'failed'].includes(existing.status)) {
+        throw new Error(`Operation ${id} is already ${existing.status}`);
+    }
+    if (!existing)
+        context.operations.create(id, params);
+    context.operations.transition(id, existing?.status === 'failed' ? 'failed' : 'pending', 'executing');
+    try {
+        const result = await run();
+        context.operations.transition(id, 'executing', 'committed', { result });
+        return result;
+    }
+    catch (error) {
+        context.operations.transition(id, 'executing', 'failed', { error: error instanceof Error ? error.message : String(error) });
+        throw error;
+    }
+}
+function requireMutationContext(context) {
+    if (!context.signer || !context.leaseProvider || !context.chainProvider || !context.localParticipant) {
+        throw new Error('Omnia mutations require signer, WOTS lease provider, chain provider, and local participant configuration');
+    }
+}
+async function persistProgramUpdate(context, channelId, run) {
+    const channel = context.channels.get(channelId);
+    if (!channel)
+        throw new Error(`Channel ${channelId} not found`);
+    const result = await run(channel);
+    if (result.error)
+        throw new Error(result.error);
+    context.channels.set(channelId, result.channel);
+    const remoteParty = channel.parties.find((party) => party.partyId !== context.localParticipant.partyId);
+    if (context.swarm && remoteParty) {
+        const peer = await context.swarm.connectToPeer(remoteParty.publicKeyDigest, channelId);
+        await peer.sendMessage({ type: 'STATE_UPDATE', channelId, nonce: Date.now(), payload: result.signedState });
+    }
+    return {
+        success: true,
+        channelId,
+        sequence: result.channel.currentSequence,
+        balances: balancesJson(result.channel),
+    };
+}
+function createHostMethods(context) {
+    const methods = new Map();
+    const register = (name, handler, alias) => {
+        methods.set(name, handler);
+        methods.set(alias, handler);
+    };
+    const getChannels = (raw) => {
+        const params = paramsObject(raw);
+        const tokenId = typeof params.tokenId === 'string' ? params.tokenId : undefined;
+        const status = typeof params.status === 'string' ? params.status : undefined;
+        const channels = Array.from(context.channels.values())
+            .filter((channel) => !tokenId || channel.tokenId === tokenId)
+            .filter((channel) => !status || channel.status === status)
+            .map(channelSummary);
+        return { channels };
+    };
+    register('totem_omniaGetChannels', getChannels, 'omnia/getChannels');
+    const getRoute = async (raw) => {
+        context.refreshRouting?.();
+        const params = paramsObject(raw);
+        const route = await context.routing.getRoute({
+            from: requiredString(params, 'fromPartyId'),
+            to: requiredString(params, 'toPartyId'),
+            amount: requiredBigInt(params, 'amount'),
+            tokenId: requiredString(params, 'tokenId'),
+            targetTokenId: typeof params.targetTokenId === 'string' ? params.targetTokenId : undefined,
+            maxHops: typeof params.maxHops === 'number' ? params.maxHops : undefined,
+        });
+        if (!route)
+            return { success: false, error: 'No route found', errorCode: 'ROUTE_NOT_FOUND' };
+        return {
+            success: true,
+            route: {
+                ...route,
+                totalFees: route.totalFees.toString(),
+                hops: route.hops.map((hop) => ({
+                    ...hop,
+                    amount: hop.amount.toString(),
+                    ...('isSwap' in hop && hop.isSwap ? {
+                        amountIn: hop.amountIn.toString(),
+                        amountOut: hop.amountOut.toString(),
+                    } : {}),
+                })),
+            },
+        };
+    };
+    register('totem_omniaGetRoute', getRoute, 'omnia/getRoute');
+    const getSwapRate = () => ({ success: true, announcements: [] });
+    register('totem_omniaGetSwapRate', getSwapRate, 'omnia/getSwapRate');
+    const openChannel = async (raw) => {
+        const params = paramsObject(raw);
+        requireMutationContext(context);
+        const remotePartyId = requiredString(params, 'remotePartyId');
+        const remotePublicKeyDigest = requiredString(params, 'remotePublicKeyDigest');
+        const remote = {
+            partyId: remotePartyId,
+            publicKeyDigest: remotePublicKeyDigest,
+            addressIndex: typeof params.remoteAddressIndex === 'number' ? params.remoteAddressIndex : 0,
+            settlementAddress: typeof params.remoteSettlementAddress === 'string' ? params.remoteSettlementAddress : undefined,
+        };
+        const result = await withOperation(context, params, async () => {
+            const createParams = {
+                localParty: context.localParticipant,
+                remoteParty: remote,
+                localAmount: requiredBigInt(params, 'localAmount'),
+                remoteAmount: requiredBigInt(params, 'remoteAmount'),
+                tokenId: typeof params.tokenId === 'string' ? params.tokenId : undefined,
+                fundingCoinId: requiredString(params, 'fundingCoinId'),
+                fundingWitnessBytes: Buffer.from(requiredString(params, 'fundingWitnessHex').replace(/^0x/i, ''), 'hex'),
+            };
+            const created = await (0, omnia_1.createChannel)(createParams, context.chainProvider);
+            context.channels.set(created.channel.channelId, {
+                ...created.channel,
+                localSigner: context.signer,
+            });
+            if (context.swarm) {
+                const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, created.channel.channelId);
+                await peer.sendMessage({ type: 'CHANNEL_PROPOSAL', channelId: created.channel.channelId, nonce: Date.now(), payload: created.proposal });
+            }
+            return { success: true, channelId: created.channel.channelId, fundingTxId: created.channel.fundingTxId };
+        });
+        return result;
+    };
+    register('totem_omniaOpenChannel', openChannel, 'omnia/openChannel');
+    const pay = async (raw) => {
+        const params = paramsObject(raw);
+        requireMutationContext(context);
+        const channelId = requiredString(params, 'channelId');
+        const amount = requiredBigInt(params, 'amount');
+        return withOperation(context, params, async () => {
+            const channel = context.channels.get(channelId);
+            if (!channel)
+                throw new Error(`Channel ${channelId} not found`);
+            const localPartyId = context.localParticipant.partyId;
+            const remotePartyId = channel.parties.find((party) => party.partyId !== localPartyId)?.partyId;
+            if (!remotePartyId)
+                throw new Error('Channel counterparty not found');
+            if (amount <= 0n || (channel.balances[localPartyId] ?? 0n) < amount)
+                throw new Error('Insufficient channel balance');
+            const result = await (0, omnia_1.updateState)(channel, {
+                newBalances: {
+                    ...channel.balances,
+                    [localPartyId]: (channel.balances[localPartyId] ?? 0n) - amount,
+                    [remotePartyId]: (channel.balances[remotePartyId] ?? 0n) + amount,
+                },
+            }, context.leaseProvider, context.signer);
+            if (result.error)
+                throw new Error(result.error);
+            context.channels.set(channelId, result.channel);
+            const peer = context.swarm ? await context.swarm.connectToPeer(channel.parties.find((party) => party.partyId === remotePartyId).publicKeyDigest, channelId) : undefined;
+            if (peer)
+                await peer.sendMessage({ type: 'STATE_UPDATE', channelId, nonce: Date.now(), payload: result.signedState });
+            return { success: true, channelId, sequence: result.channel.currentSequence, localBalance: result.channel.balances[localPartyId].toString(), remoteBalance: result.channel.balances[remotePartyId].toString() };
+        });
+    };
+    register('totem_omniaPay', pay, 'omnia/pay');
+    const programTransition = async (raw) => {
+        const params = paramsObject(raw);
+        requireMutationContext(context);
+        const channelId = requiredString(params, 'channelId');
+        const transition = {
+            action: requiredString(params, 'action'),
+            inputs: optionalTransitionInputs(params),
+            witness: optionalStringRecord(params, 'witness'),
+            metadata: optionalStringRecord(params, 'metadata'),
+        };
+        const balances = bigintRecord(params, 'balances');
+        return withOperation(context, params, async () => persistProgramUpdate(context, channelId, (channel) => (0, omnia_1.applyProgramTransition)(channel, { transition, balances }, context.leaseProvider, context.signer)));
+    };
+    register('totem_omniaApplyProgramTransition', programTransition, 'omnia/applyProgramTransition');
+    const counterTransition = (action) => async (raw) => {
+        const params = paramsObject(raw);
+        requireMutationContext(context);
+        const channelId = requiredString(params, 'channelId');
+        return withOperation(context, params, async () => persistProgramUpdate(context, channelId, (channel) => {
+            if (action === 'increment')
+                return (0, omnia_1.incrementCounter)(channel, requiredBigInt(params, 'by'), context.leaseProvider, context.signer);
+            if (action === 'decrement')
+                return (0, omnia_1.decrementCounter)(channel, requiredBigInt(params, 'by'), context.leaseProvider, context.signer);
+            return (0, omnia_1.setCounter)(channel, requiredBigInt(params, 'value'), context.leaseProvider, context.signer);
+        }));
+    };
+    register('totem_omniaIncrementCounter', counterTransition('increment'), 'omnia/incrementCounter');
+    register('totem_omniaDecrementCounter', counterTransition('decrement'), 'omnia/decrementCounter');
+    register('totem_omniaSetCounter', counterTransition('set'), 'omnia/setCounter');
+    const meterReading = async (raw) => {
+        const params = paramsObject(raw);
+        requireMutationContext(context);
+        const channelId = requiredString(params, 'channelId');
+        return withOperation(context, params, async () => persistProgramUpdate(context, channelId, (channel) => (0, omnia_1.recordMeterReading)(channel, requiredBigInt(params, 'reading'), requiredBigInt(params, 'unitPrice'), context.leaseProvider, context.signer)));
+    };
+    register('totem_omniaRecordMeterReading', meterReading, 'omnia/recordMeterReading');
+    const settle = async (raw) => {
+        const params = paramsObject(raw);
+        requireMutationContext(context);
+        const channelId = requiredString(params, 'channelId');
+        return withOperation(context, params, async () => {
+            const channel = context.channels.get(channelId);
+            if (!channel)
+                throw new Error(`Channel ${channelId} not found`);
+            const closing = (0, omnia_1.markChannelClosing)(channel, 'mutual');
+            const settlement = await (0, omnia_1.proposeSettlement)(closing, context.leaseProvider, {
+                signer: context.signer,
+                chainProvider: context.chainProvider,
+                partyAddresses: Object.fromEntries(closing.parties.map((party) => [party.partyId, party.settlementAddress ?? party.publicKeyDigest])),
+            });
+            context.channels.set(channelId, (0, omnia_1.markChannelClosed)(closing));
+            return { success: true, channelId, settlementTxId: settlement.settlementPayload.txpowId, finalBalances: Object.fromEntries(Object.entries(settlement.settlementPayload.balances).map(([key, value]) => [key, value.toString()])) };
+        });
+    };
+    register('totem_omniaSettle', settle, 'omnia/settle');
+    const closeChannel = async (raw) => {
+        const params = paramsObject(raw);
+        const channelId = requiredString(params, 'channelId');
+        return withOperation(context, params, async () => {
+            const channel = context.channels.get(channelId);
+            if (!channel)
+                throw new Error(`Channel ${channelId} not found`);
+            context.channels.set(channelId, (0, omnia_1.markChannelClosed)(channel));
+            return { success: true, channelId };
+        });
+    };
+    register('totem_omniaCloseChannel', closeChannel, 'omnia/closeChannel');
+    const createFactoryMethod = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.factories || !context.factoryBundles || !context.chainProvider)
+            throw new Error('Factory manager is not configured');
+        const participants = params.participants;
+        if (!Array.isArray(participants) || participants.length < 2)
+            throw new Error('participants must contain at least two factory participants');
+        const parsed = participants.map((value) => {
+            if (!value || typeof value !== 'object')
+                throw new Error('Invalid factory participant');
+            const item = value;
+            return {
+                partyId: requiredString(item, 'partyId'),
+                publicKeyDigest: requiredString(item, 'publicKeyDigest'),
+                addressIndex: Number(item.addressIndex ?? 0),
+                contributionAmount: BigInt(requiredString(item, 'contributionAmount')),
+                fundingCoinId: typeof item.fundingCoinId === 'string' ? item.fundingCoinId : undefined,
+                settlementAddress: typeof item.settlementAddress === 'string' ? item.settlementAddress : undefined,
+            };
+        });
+        const tokenId = typeof params.tokenId === 'string' ? params.tokenId : '0x00';
+        const bundles = context.factoryBundles;
+        const proposer = parsed.find((participant) => bundles[participant.partyId]);
+        if (!proposer)
+            throw new Error('No local factory lease bundle matches a participant');
+        return withOperation(context, params, async () => {
+            const factory = await (0, omnia_factory_1.createFactory)(parsed, tokenId, bundles[proposer.partyId], context.chainProvider);
+            context.factories.set(factory.factoryId, factory);
+            return { success: true, factoryId: factory.factoryId, fundingTxId: factory.fundingTxId };
+        });
+    };
+    register('totem_omniaCreateFactory', createFactoryMethod, 'omnia/createFactory');
+    const openVirtual = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.factories || !context.factoryBundles)
+            throw new Error('Factory manager is not configured');
+        const factoryId = requiredString(params, 'factoryId');
+        const factory = context.factories.get(factoryId);
+        if (!factory)
+            throw new Error(`Factory ${factoryId} not found`);
+        const parties = params.partyIds;
+        if (!Array.isArray(parties) || parties.length !== 2 || !parties.every((value) => typeof value === 'string'))
+            throw new Error('partyIds must contain two party IDs');
+        const amounts = params.amounts;
+        if (!amounts || typeof amounts !== 'object')
+            throw new Error('amounts is required');
+        const parsedAmounts = Object.fromEntries(Object.entries(amounts).map(([key, value]) => [key, BigInt(String(value))]));
+        return withOperation(context, params, async () => {
+            const result = await (0, omnia_factory_1.openVirtualChannel)(factory, parties, parsedAmounts, context.factoryBundles);
+            context.factories.set(factoryId, result.factory);
+            context.channels.set(result.channel.channelId, result.channel);
+            return { success: true, channelId: result.channel.channelId, factoryId };
+        });
+    };
+    register('totem_omniaOpenVirtualChannel', openVirtual, 'omnia/openVirtualChannel');
+    const closeFactoryMethod = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.factories || !context.factoryBundles || !context.chainProvider)
+            throw new Error('Factory manager is not configured');
+        const factoryId = requiredString(params, 'factoryId');
+        const factory = context.factories.get(factoryId);
+        if (!factory)
+            throw new Error(`Factory ${factoryId} not found`);
+        return withOperation(context, params, async () => {
+            const payload = await (0, omnia_factory_1.closeFactory)(factory, context.factoryBundles, context.chainProvider);
+            context.factories.set(factoryId, { ...factory, status: 'closed' });
+            return { success: true, factoryId, settlementTxId: payload.txpowId, finalAllocations: Object.fromEntries(Object.entries(payload.finalAllocations).map(([key, value]) => [key, value.toString()])) };
+        });
+    };
+    register('totem_omniaCloseFactory', closeFactoryMethod, 'omnia/closeFactory');
+    const splice = (type) => async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.spliceLeaseProvider || !context.spliceProposals)
+            throw new Error('Splice manager is not configured');
+        const channelId = requiredString(params, 'channelId');
+        const channel = context.channels.get(channelId);
+        if (!channel)
+            throw new Error(`Channel ${channelId} not found`);
+        return withOperation(context, params, async () => {
+            const quiesced = await (0, omnia_splice_1.quiesceChannel)(channel, context.spliceLeaseProvider);
+            const proposal = type === 'in'
+                ? await (0, omnia_splice_1.proposeSpliceIn)(quiesced, requiredString(params, 'additionalCoinId'), requiredBigInt(params, 'additionalAmount'), context.spliceLeaseProvider, params.newBalances)
+                : await (0, omnia_splice_1.proposeSpliceOut)(quiesced, requiredBigInt(params, 'withdrawAmount'), requiredString(params, 'withdrawAddress'), context.spliceLeaseProvider, params.newBalances);
+            context.spliceProposals.set(proposal.spliceId, proposal);
+            context.channels.set(channelId, quiesced);
+            return { success: true, channelId, spliceId: proposal.spliceId, updatedChannelState: proposal.spliceTxHex };
+        });
+    };
+    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');
+    };
+    register('totem_omniaPayMultiHop', unsupported, 'omnia/payMultiHop');
+    return methods;
+}

package/dist/chain/totem-node-adapter.d.ts

@@ -0,0 +1,23 @@
+import type { ChainStateProvider, ChainTip } from '@totemsdk/chain-provider';
+import { type MinimaRpcClient } from '@totemsdk/minima-rpc';
+export interface TotemNodeAdapterOptions {
+    host: string;
+    port: number;
+    password?: string;
+    ssl?: boolean;
+    pollIntervalMs?: number;
+    provider?: ChainStateProvider;
+    client?: MinimaRpcClient;
+}
+export interface ConfirmationOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    minConfirmations?: number;
+}
+export interface TotemNodeAdapter extends ChainStateProvider {
+    getMode(): Promise<string | undefined>;
+    waitForConfirmation(coinId: string, options?: ConfirmationOptions): Promise<void>;
+    subscribe(listener: (tip: ChainTip) => void): () => void;
+    close(): void;
+}
+export declare function createTotemNodeAdapter(options: TotemNodeAdapterOptions): TotemNodeAdapter;