@totemsdk/omnia-host 0.8.0 → 0.10.0

package/dist/api/jsonrpc.js

@@ -27,8 +27,12 @@ async function dispatch(request, methods) {
         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');
+        // Surface the handler's message to the caller. Masking it as "Internal
+        // error" made operational failures (broadcast rejection, missing manager,
+        // malformed params) impossible to diagnose from the client side.
+        const message = error instanceof Error ? error.message : String(error);
+        console.error('[jsonrpc] handler error:', error instanceof Error ? error.stack ?? message : message);
+        return errorResponse(request.id, -32000, message);
     }
 }
 async function readBody(req) {

package/dist/api/methods.d.ts

@@ -17,6 +17,14 @@ export interface HostApiContext {
     chainProvider?: ChainStateProvider;
     swarm?: OmniaSwarm;
     localParticipant?: ChannelParticipant;
+    /** Native transport identity, published in the signed manifest. */
+    transportPubkey?: string;
+    /**
+     * Signs the funding-transaction digest with the funding coin's key, so
+     * openChannel can assemble the funding witness without the caller reproducing
+     * the funding draft. Configured from the node's `sign` command.
+     */
+    fundingSigner?: (digest: Uint8Array) => Promise<Uint8Array> | Uint8Array;
     factories?: Map<string, ChannelFactory>;
     factoryBundles?: Record<string, WotsLeaseBundle>;
     spliceProposals?: Map<string, SpliceProposal>;
@@ -39,4 +47,36 @@ export interface HostApiContext {
  * read everything they need without reaching into `getStore()`/`getMethods()`.
  */
 export declare function channelStateView(channel: OmniaChannel): Record<string, unknown>;
+/**
+ * Wait for the counterparty to acknowledge a channel proposal. A channel is not
+ * usable on both sides until the peer has accepted it; without this, an
+ * immediate `pay()` can race ahead of the peer's accept and its STATE_UPDATE is
+ * dropped ("Unknown channel"). Resolves true on ACK, false on ERROR/timeout.
+ */
+interface PeerReply {
+    type: string;
+    channelId?: string;
+    nonce?: number;
+    payload?: unknown;
+}
+interface ReplyPeer {
+    sendMessage(msg: PeerReply & {
+        channelId: string;
+    }): Promise<void>;
+    onMessage(cb: (msg: PeerReply) => void): () => void;
+    onReconnected?(cb: () => void): () => void;
+}
+/**
+ * Send a proposal and wait for its ACK/ERROR reply.
+ *
+ * The message is resent with the SAME nonce when the peer reconnects (a
+ * proposal or its reply may have been lost when the old stream closed) and
+ * once mid-flight in case the reply was lost without the stream closing.
+ * Receivers are expected to deduplicate by `(type, channelId, nonce)` so a
+ * resend never consumes another WOTS leaf or yields a different signature.
+ */
+export declare function requestPeerReply(peer: ReplyPeer, msg: PeerReply & {
+    channelId: string;
+}, channelId: string, timeoutMs: number, types?: string[]): Promise<PeerReply | null>;
 export declare function createHostMethods(context: HostApiContext): Map<string, JsonRpcHandler>;
+export {};

package/dist/api/methods.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.channelStateView = channelStateView;
+exports.requestPeerReply = requestPeerReply;
 exports.createHostMethods = createHostMethods;
 const omnia_1 = require("@totemsdk/omnia");
 const omnia_router_1 = require("@totemsdk/omnia-router");
@@ -48,8 +49,10 @@ function channelStateView(channel) {
         totalValue: channel.totalValue,
         currentSequence: channel.currentSequence,
         fundingAddress: channel.fundingAddress,
+        fundingScript: channel.fundingScript,
         fundingTxId: channel.fundingTxId,
         fundingCoinId: channel.fundingCoinId,
+        contestDelayBlocks: channel.contestDelayBlocks,
         parties: channel.parties,
         balances: channel.balances,
         pendingHTLCs: channel.pendingHTLCs,
@@ -174,7 +177,7 @@ async function persistProgramUpdate(context, channelId, run) {
     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);
+        const peer = await context.swarm.connectToPeer(remoteParty.publicKeyDigest, channelId, remoteParty.transportPubkey);
         await peer.sendMessage({ type: 'STATE_UPDATE', channelId, nonce: Date.now(), payload: result.signedState });
     }
     return {
@@ -184,6 +187,57 @@ async function persistProgramUpdate(context, channelId, run) {
         balances: balancesJson(result.channel),
     };
 }
+/**
+ * Send a proposal and wait for its ACK/ERROR reply.
+ *
+ * The message is resent with the SAME nonce when the peer reconnects (a
+ * proposal or its reply may have been lost when the old stream closed) and
+ * once mid-flight in case the reply was lost without the stream closing.
+ * Receivers are expected to deduplicate by `(type, channelId, nonce)` so a
+ * resend never consumes another WOTS leaf or yields a different signature.
+ */
+function requestPeerReply(peer, msg, channelId, timeoutMs, types = ['ACK', 'ERROR']) {
+    return new Promise((resolve) => {
+        let done = false;
+        let timer;
+        let fallback;
+        const unsubs = [];
+        const finish = (reply) => {
+            if (done)
+                return;
+            done = true;
+            if (timer)
+                clearTimeout(timer);
+            if (fallback)
+                clearTimeout(fallback);
+            for (const unsub of unsubs)
+                unsub();
+            resolve(reply);
+        };
+        const resend = (reason) => {
+            if (done)
+                return;
+            if (process.env.OMNIA_DEBUG) {
+                console.error('[peer] resend', msg.type, msg.nonce, reason, channelId);
+            }
+            void peer.sendMessage(msg).catch(() => { });
+        };
+        unsubs.push(peer.onMessage((reply) => {
+            if (reply.channelId !== channelId)
+                return;
+            if (msg.nonce !== undefined && reply.nonce !== undefined && reply.nonce !== msg.nonce)
+                return;
+            if (types.includes(reply.type))
+                finish(reply);
+        }));
+        if (peer.onReconnected) {
+            unsubs.push(peer.onReconnected(() => resend('reconnected')));
+        }
+        fallback = setTimeout(() => resend('no reply'), Math.min(10_000, Math.floor(timeoutMs / 2)));
+        timer = setTimeout(() => finish(null), timeoutMs);
+        void peer.sendMessage(msg).catch(() => { });
+    });
+}
 function createHostMethods(context) {
     const methods = new Map();
     const register = (name, handler, alias) => {
@@ -276,27 +330,70 @@ function createHostMethods(context) {
             publicKeyDigest: remotePublicKeyDigest,
             addressIndex: typeof params.remoteAddressIndex === 'number' ? params.remoteAddressIndex : 0,
             settlementAddress: typeof params.remoteSettlementAddress === 'string' ? params.remoteSettlementAddress : undefined,
+            transportPubkey: typeof params.remoteTransportPubkey === 'string' ? params.remoteTransportPubkey : undefined,
         };
         const result = await withOperation(context, params, async () => {
             const createParams = {
-                localParty: context.localParticipant,
+                localParty: {
+                    ...context.localParticipant,
+                    transportPubkey: context.localParticipant.transportPubkey ?? context.transportPubkey,
+                },
                 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'),
+                contestDelayBlocks: typeof params.contestDelayBlocks === 'number' ? params.contestDelayBlocks : undefined,
             };
+            const fundingWitnessHex = typeof params.fundingWitnessHex === 'string' ? params.fundingWitnessHex : undefined;
+            if (fundingWitnessHex) {
+                createParams.fundingWitnessBytes = Buffer.from(fundingWitnessHex.replace(/^0x/i, ''), 'hex');
+            }
+            else {
+                // Assemble the funding witness: createChannel builds the funding draft,
+                // a funding signer signs its digest, and the caller supplies the input
+                // proofs (serialized CoinProof + ScriptProof). The signer comes from the
+                // configured funding signer, or from the node's `sign` command using the
+                // `fundingPubkey` the caller passes.
+                const fundingPubkey = typeof params.fundingPubkey === 'string' ? params.fundingPubkey : undefined;
+                const nodeAdapter = context.chainProvider;
+                const signer = context.fundingSigner ?? (fundingPubkey && typeof nodeAdapter?.signData === 'function'
+                    ? async (digest) => {
+                        const sig = await nodeAdapter.signData(fundingPubkey, '0x' + Buffer.from(digest).toString('hex'));
+                        return Uint8Array.from(Buffer.from(sig.replace(/^0x/i, ''), 'hex'));
+                    }
+                    : undefined);
+                if (!signer) {
+                    throw new Error('openChannel requires fundingWitnessHex, or a fundingPubkey + funding proofs');
+                }
+                if (typeof params.fundingScript !== 'string' && !Array.isArray(params.fundingScriptProofsHex)) {
+                    throw new Error('openChannel requires fundingScript (or serialized fundingScriptProofsHex) for the funding input address');
+                }
+                const toBytes = (v) => Array.isArray(v) ? v.map((h) => Buffer.from(String(h).replace(/^0x/i, ''), 'hex')) : [];
+                createParams.fundingProofs = {
+                    coinProofs: toBytes(params.fundingCoinProofsHex),
+                    scriptProofs: toBytes(params.fundingScriptProofsHex),
+                };
+                // The funding coin's address script: createChannel derives the required
+                // single-leaf ScriptProof from it, so callers need not hand-roll it.
+                if (typeof params.fundingScript === 'string') {
+                    createParams.fundingScript = params.fundingScript;
+                }
+                createParams.fundingSigner = signer;
+            }
             const created = await (0, omnia_1.createChannel)(createParams, context.chainProvider);
             context.channels.set(created.channel.channelId, {
                 ...created.channel,
                 localSigner: context.signer,
             });
+            let acknowledged = true;
             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 });
+                const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, created.channel.channelId, remote.transportPubkey);
+                // Give the peer time to accept so a follow-up pay() is not lost.
+                const reply = await requestPeerReply(peer, { type: 'CHANNEL_PROPOSAL', channelId: created.channel.channelId, nonce: Date.now(), payload: created.proposal }, created.channel.channelId, 20_000);
+                acknowledged = reply?.type === 'ACK';
             }
-            return { success: true, channelId: created.channel.channelId, fundingTxId: created.channel.fundingTxId };
+            return { success: true, channelId: created.channel.channelId, fundingTxId: created.channel.fundingTxId, acknowledged };
         });
         return result;
     };
@@ -326,7 +423,8 @@ function createHostMethods(context) {
             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;
+            const remoteParty = channel.parties.find((party) => party.partyId === remotePartyId);
+            const peer = context.swarm ? await context.swarm.connectToPeer(remoteParty.publicKeyDigest, channelId, remoteParty.transportPubkey) : 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() };
@@ -387,11 +485,42 @@ function createHostMethods(context) {
             if (!channel)
                 throw new Error(`Channel ${channelId} not found`);
             const closing = (0, omnia_1.markChannelClosing)(channel, 'mutual');
+            const partyAddresses = Object.fromEntries(closing.parties.map((party) => [party.partyId, party.settlementAddress ?? party.publicKeyDigest]));
+            // Cooperative close needs both eltoo MULTISIG(2 A B) signatures. Build the
+            // exact settlement draft, ask the counterparty to co-sign it, then include
+            // both signatures in the broadcast witness.
+            const localPartyId = context.localParticipant?.partyId;
+            const remoteParty = localPartyId
+                ? closing.parties.find((party) => party.partyId !== localPartyId)
+                : undefined;
+            let counterpartySignatures;
+            let settlementTxHex;
+            if (context.swarm && remoteParty) {
+                const request = (0, omnia_1.buildSettlementSigningRequest)(closing, { partyAddresses });
+                const peer = await context.swarm.connectToPeer(remoteParty.publicKeyDigest, channelId, remoteParty.transportPubkey);
+                const reply = await requestPeerReply(peer, {
+                    type: 'SETTLEMENT_PROPOSAL',
+                    channelId,
+                    nonce: Date.now(),
+                    payload: { signRequest: true, ...request },
+                }, channelId, 30_000);
+                const replyPayload = reply?.payload;
+                if (reply?.type !== 'ACK' || typeof replyPayload?.signature !== 'string') {
+                    throw new Error(`Counterparty did not co-sign the settlement (${reply?.type ?? 'timeout'})`);
+                }
+                counterpartySignatures = [{
+                        partyId: replyPayload.partyId ?? remoteParty.partyId,
+                        signature: Buffer.from(replyPayload.signature.replace(/^0x/i, ''), 'hex'),
+                    }];
+                settlementTxHex = request.settlementTxHex;
+            }
             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])),
+                partyAddresses,
+                settlementTxHex,
+                counterpartySignatures,
             });
             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()])) };
@@ -412,7 +541,7 @@ function createHostMethods(context) {
     register('totem_omniaCloseChannel', closeChannel, 'omnia/closeChannel');
     const createFactoryMethod = async (raw) => {
         const params = paramsObject(raw);
-        if (!context.factories || !context.factoryBundles || !context.chainProvider)
+        if (!context.factories || !context.factoryBundles)
             throw new Error('Factory manager is not configured');
         const participants = params.participants;
         if (!Array.isArray(participants) || participants.length < 2)
@@ -428,17 +557,106 @@ function createHostMethods(context) {
                 contributionAmount: BigInt(requiredString(item, 'contributionAmount')),
                 fundingCoinId: typeof item.fundingCoinId === 'string' ? item.fundingCoinId : undefined,
                 settlementAddress: typeof item.settlementAddress === 'string' ? item.settlementAddress : undefined,
+                transportPubkey: typeof item.transportPubkey === 'string' ? item.transportPubkey : undefined,
             };
         });
+        const localPartyId = context.localParticipant?.partyId;
+        if (!localPartyId)
+            throw new Error('Local participant is not configured');
+        const localBundle = context.factoryBundles[localPartyId];
+        if (!localBundle)
+            throw new Error('No local factory lease bundle');
+        const remote = parsed.find((participant) => participant.partyId !== localPartyId);
+        const localSigner = context.signer && context.leaseProvider
+            ? async (digest) => {
+                const reservation = await context.leaseProvider.reserveKeyUse({
+                    treeId: 'factory-funding',
+                    purpose: 'factory-funding',
+                    payloadHash: '0x' + Buffer.from(digest).toString('hex'),
+                });
+                try {
+                    const sig = await context.signer.sign(digest, reservation.indices);
+                    await context.leaseProvider.commitKeyUse(reservation.reservationId, 'factory-funding');
+                    return sig;
+                }
+                catch (err) {
+                    await context.leaseProvider.burnReservation(reservation.reservationId, 'factory-funding-failed').catch(() => { });
+                    throw err;
+                }
+            }
+            : undefined;
+        let fundingPeer;
+        const remoteSigner = context.swarm && remote
+            ? async (digest) => {
+                fundingPeer ??= await context.swarm.connectToPeer(remote.publicKeyDigest, 'factory-funding', remote.transportPubkey);
+                const channelId = 'factory-funding';
+                const reply = await requestPeerReply(fundingPeer, {
+                    type: 'FACTORY_FUNDING_REQUEST',
+                    channelId,
+                    nonce: Date.now(),
+                    payload: { digest: '0x' + Buffer.from(digest).toString('hex') },
+                }, channelId, 30_000, ['FACTORY_FUNDING_RESPONSE', 'ERROR']);
+                const signature = reply?.payload?.signature;
+                if (!signature) {
+                    throw new Error(`Counterparty did not co-sign factory funding (${reply?.type ?? 'timeout'})`);
+                }
+                return Uint8Array.from(Buffer.from(signature.replace(/^0x/i, ''), 'hex'));
+            }
+            : undefined;
+        const funding = Array.isArray(params.funding)
+            ? params.funding.map((value) => {
+                if (!value || typeof value !== 'object')
+                    throw new Error('Invalid factory funding material');
+                const item = value;
+                const hex = (key) => {
+                    const raw = item[key];
+                    if (typeof raw !== 'string')
+                        return undefined;
+                    return Buffer.from(raw.replace(/^0x/i, ''), 'hex');
+                };
+                const coinProof = hex('coinProof');
+                if (!coinProof)
+                    throw new Error('factory funding material requires coinProof');
+                const partyId = requiredString(item, 'partyId');
+                const signature = hex('signature');
+                const signer = signature
+                    ? undefined
+                    : partyId === localPartyId
+                        ? localSigner
+                        : remoteSigner;
+                return {
+                    partyId,
+                    coinProof,
+                    ...(typeof item.coinAddress === 'string' ? { coinAddress: item.coinAddress } : {}),
+                    ...(typeof item.script === 'string' ? { script: item.script } : {}),
+                    ...(hex('scriptProof') ? { scriptProof: hex('scriptProof') } : {}),
+                    ...(signature ? { signature } : signer ? { signer } : {}),
+                };
+            })
+            : 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);
+            // Off-chain when no funding material is supplied; with funding material the
+            // SDK builds, signs, and submits the on-chain factory funding TX.
+            let factory = await (0, omnia_factory_1.createFactory)(parsed, tokenId, localBundle, context.chainProvider, 0, funding);
+            if (context.swarm && remote) {
+                const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, factory.factoryId, remote.transportPubkey);
+                const reply = await requestPeerReply(peer, {
+                    type: 'FACTORY_PROPOSAL',
+                    channelId: factory.factoryId,
+                    nonce: Date.now(),
+                    payload: { factory },
+                }, factory.factoryId, 30_000, ['FACTORY_ACCEPT', 'ERROR']);
+                if (reply?.type !== 'FACTORY_ACCEPT') {
+                    throw new Error(`Counterparty did not accept the factory (${reply?.type ?? 'timeout'})`);
+                }
+                const accepted = reply.payload?.factory;
+                if (!accepted)
+                    throw new Error('Factory accept reply missing factory');
+                factory = accepted;
+            }
             context.factories.set(factory.factoryId, factory);
-            return { success: true, factoryId: factory.factoryId, fundingTxId: factory.fundingTxId };
+            return { success: true, factoryId: factory.factoryId, status: factory.status };
         });
     };
     register('totem_omniaCreateFactory', createFactoryMethod, 'omnia/createFactory');
@@ -457,14 +675,109 @@ function createHostMethods(context) {
         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))]));
+        const localPartyId = context.localParticipant?.partyId;
+        if (!localPartyId)
+            throw new Error('Local participant is not configured');
+        const localBundle = context.factoryBundles[localPartyId];
+        if (!localBundle)
+            throw new Error('No local factory lease bundle');
         return withOperation(context, params, async () => {
-            const result = await (0, omnia_factory_1.openVirtualChannel)(factory, parties, parsedAmounts, context.factoryBundles);
+            const plan = (0, omnia_factory_1.buildVirtualChannelOpen)(factory, parties, parsedAmounts);
+            const localSig = await (0, omnia_factory_1.signVirtualChannelOpen)(factory, plan, localBundle);
+            const signatures = { [localSig.partyId]: localSig };
+            const remote = factory.participants.find((participant) => participant.partyId !== localPartyId);
+            const peer = context.swarm && remote
+                ? await context.swarm.connectToPeer(remote.publicKeyDigest, plan.vcId, remote.transportPubkey)
+                : undefined;
+            if (peer) {
+                const reply = await requestPeerReply(peer, {
+                    type: 'VC_PROPOSAL',
+                    channelId: plan.vcId,
+                    nonce: Date.now(),
+                    payload: { kind: 'vc-open', factoryId, vcId: plan.vcId, plan },
+                }, plan.vcId, 30_000, ['VC_ACCEPT', 'ERROR']);
+                const sig = reply?.payload?.signature;
+                if (reply?.type !== 'VC_ACCEPT' || !sig) {
+                    throw new Error(`Counterparty did not sign the virtual-channel open (${reply?.type ?? 'timeout'})`);
+                }
+                signatures[sig.partyId] = sig;
+            }
+            const result = (0, omnia_factory_1.assembleVirtualChannelOpen)(factory, plan, signatures);
+            await localBundle.leaseProvider.commitKeyUse(localSig.reservationId, `factory-vc-open-${factoryId}`);
+            if (peer) {
+                await peer.sendMessage({
+                    type: 'VC_FINALIZED',
+                    channelId: plan.vcId,
+                    nonce: Date.now(),
+                    payload: { kind: 'vc-open', factory: result.factory, channel: result.channel },
+                });
+            }
             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 closeVirtual = 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 channelId = requiredString(params, 'channelId');
+        const factory = context.factories.get(factoryId);
+        if (!factory)
+            throw new Error(`Factory ${factoryId} not found`);
+        const channel = context.channels.get(channelId);
+        if (!channel)
+            throw new Error(`Channel ${channelId} not found`);
+        const localPartyId = context.localParticipant?.partyId;
+        if (!localPartyId)
+            throw new Error('Local participant is not configured');
+        const localBundle = context.factoryBundles[localPartyId];
+        if (!localBundle)
+            throw new Error('No local factory lease bundle');
+        return withOperation(context, params, async () => {
+            const plan = (0, omnia_factory_1.buildVirtualChannelClose)(factory, channel);
+            const localSig = await (0, omnia_factory_1.signVirtualChannelClose)(factory, plan, localBundle);
+            const signatures = { [localSig.partyId]: localSig };
+            const remote = factory.participants.find((participant) => participant.partyId !== localPartyId);
+            const peer = context.swarm && remote
+                ? await context.swarm.connectToPeer(remote.publicKeyDigest, plan.vcId, remote.transportPubkey)
+                : undefined;
+            if (peer) {
+                const reply = await requestPeerReply(peer, {
+                    type: 'VC_PROPOSAL',
+                    channelId: plan.vcId,
+                    nonce: Date.now(),
+                    payload: { kind: 'vc-close', factoryId, vcId: plan.vcId, plan },
+                }, plan.vcId, 30_000, ['VC_ACCEPT', 'ERROR']);
+                const sig = reply?.payload?.signature;
+                if (reply?.type !== 'VC_ACCEPT' || !sig) {
+                    throw new Error(`Counterparty did not sign the virtual-channel close (${reply?.type ?? 'timeout'})`);
+                }
+                signatures[sig.partyId] = sig;
+            }
+            const updated = (0, omnia_factory_1.assembleVirtualChannelClose)(factory, plan, signatures);
+            await localBundle.leaseProvider.commitKeyUse(localSig.reservationId, `factory-vc-close-${factoryId}`);
+            if (peer) {
+                await peer.sendMessage({
+                    type: 'VC_FINALIZED',
+                    channelId: plan.vcId,
+                    nonce: Date.now(),
+                    payload: { kind: 'vc-close', factory: updated, channelId },
+                });
+            }
+            context.factories.set(factoryId, updated);
+            context.channels.delete(channelId);
+            return {
+                success: true,
+                factoryId,
+                channelId,
+                allocations: Object.fromEntries(Object.entries(updated.allocations).map(([k, v]) => [k, v.toString()])),
+            };
+        });
+    };
+    register('totem_omniaCloseVirtualChannel', closeVirtual, 'omnia/closeVirtualChannel');
     const closeFactoryMethod = async (raw) => {
         const params = paramsObject(raw);
         if (!context.factories || !context.factoryBundles || !context.chainProvider)
@@ -473,29 +786,116 @@ function createHostMethods(context) {
         const factory = context.factories.get(factoryId);
         if (!factory)
             throw new Error(`Factory ${factoryId} not found`);
+        const coinProofRaw = params.coinProof
+            ?? params.broadcastProofs?.coinProofs;
+        const coinProofHex = Array.isArray(coinProofRaw) ? coinProofRaw[0] : coinProofRaw;
+        const coinProof = typeof coinProofHex === 'string'
+            ? Buffer.from(coinProofHex.replace(/^0x/i, ''), 'hex')
+            : undefined;
         return withOperation(context, params, async () => {
-            const payload = await (0, omnia_factory_1.closeFactory)(factory, context.factoryBundles, context.chainProvider);
+            const localPartyId = context.localParticipant?.partyId;
+            const localBundle = localPartyId ? context.factoryBundles[localPartyId] : undefined;
+            if (!localPartyId || !localBundle)
+                throw new Error('No local factory lease bundle');
+            const remote = factory.participants.find((participant) => participant.partyId !== localPartyId);
+            let payload;
+            if (context.swarm && remote) {
+                // Cooperative close: build/sign locally, collect the counterparty
+                // signature over the same draft, then assemble and broadcast once.
+                const draft = (0, omnia_factory_1.buildFactorySettlement)(factory);
+                const localSig = await (0, omnia_factory_1.signFactorySettlement)(factory, draft, localBundle);
+                const signatures = { [localSig.partyId]: localSig };
+                const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, factoryId, remote.transportPubkey);
+                const message = {
+                    type: 'FACTORY_CLOSE_PROPOSAL',
+                    channelId: factoryId,
+                    nonce: Date.now(),
+                    payload: { factoryId, draft },
+                };
+                const reply = await requestPeerReply(peer, message, factoryId, 30_000, ['FACTORY_CLOSE_ACCEPT', 'ERROR']);
+                const remoteSig = reply?.payload?.signature;
+                if (reply?.type !== 'FACTORY_CLOSE_ACCEPT' || !remoteSig) {
+                    throw new Error(`Counterparty did not co-sign the factory close (${reply?.type ?? 'timeout'})`);
+                }
+                signatures[remoteSig.partyId] = remoteSig;
+                payload = await (0, omnia_factory_1.assembleFactorySettlement)(factory, draft, signatures, context.chainProvider, { coinProof });
+                await localBundle.leaseProvider.commitKeyUse(localSig.reservationId, `factory-settlement-${factoryId}`);
+                await peer.sendMessage({
+                    type: 'FACTORY_CLOSE_FINALIZED',
+                    channelId: factoryId,
+                    nonce: message.nonce,
+                    payload: { factoryId, txId: payload.txpowId },
+                });
+            }
+            else {
+                payload = await (0, omnia_factory_1.closeFactory)(factory, context.factoryBundles, context.chainProvider, { coinProof });
+            }
             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()])) };
+            const finalAllocations = payload.finalAllocations;
+            return { success: true, factoryId, settlementTxId: payload.txpowId, finalAllocations: Object.fromEntries(Object.entries(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)
+        if (!context.spliceLeaseProvider || !context.spliceProposals || !context.spliceAcceptances) {
             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`);
+        const localPartyId = context.localParticipant?.partyId;
+        if (!localPartyId)
+            throw new Error('Local participant is not configured');
+        const remote = channel.parties.find((party) => party.partyId !== localPartyId);
+        if (!context.swarm || !remote)
+            throw new Error('Splice requires a counterparty');
+        const swarm = context.swarm;
         return withOperation(context, params, async () => {
-            const quiesced = await (0, omnia_splice_1.quiesceChannel)(channel, context.spliceLeaseProvider);
+            const provider = context.spliceLeaseProvider;
+            const quiesced = await (0, omnia_splice_1.quiesceChannel)(channel, provider);
             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);
+                ? await (0, omnia_splice_1.proposeSpliceIn)(quiesced, requiredString(params, 'additionalCoinId'), requiredBigInt(params, 'additionalAmount'), provider, params.newBalances)
+                : await (0, omnia_splice_1.proposeSpliceOut)(quiesced, requiredBigInt(params, 'withdrawAmount'), requiredString(params, 'withdrawAddress'), provider, params.newBalances);
             context.spliceProposals.set(proposal.spliceId, proposal);
-            context.channels.set(channelId, quiesced);
-            return { success: true, channelId, spliceId: proposal.spliceId, updatedChannelState: proposal.spliceTxHex };
+            const peer = await swarm.connectToPeer(remote.publicKeyDigest, channelId, remote.transportPubkey);
+            const proposalMessage = {
+                type: 'SPLICE_PROPOSAL',
+                channelId,
+                nonce: Date.now(),
+                payload: { proposal },
+            };
+            const reply = await requestPeerReply(peer, proposalMessage, channelId, 30_000, ['SPLICE_ACCEPT', 'ERROR']);
+            const acceptance = reply?.payload?.acceptance;
+            if (reply?.type !== 'SPLICE_ACCEPT' || !acceptance) {
+                throw new Error(`Counterparty did not accept the splice (${reply?.type ?? 'timeout'})`);
+            }
+            context.spliceAcceptances.set(proposal.spliceId, acceptance);
+            const spliced = await (0, omnia_splice_1.finalizeSplice)(quiesced, proposal, acceptance, {
+                ...(provider.broadcast ? { broadcast: provider.broadcast } : {}),
+                proposerLeaseProvider: provider.wotsLease,
+            });
+            context.channels.set(channelId, spliced);
+            await peer.sendMessage({
+                type: 'SPLICE_FINALIZED',
+                channelId,
+                nonce: proposalMessage.nonce,
+                payload: {
+                    channel: spliced,
+                    txId: spliced.spliceFundingTxId,
+                    spliceId: proposal.spliceId,
+                },
+            });
+            return {
+                success: true,
+                channelId,
+                spliceId: proposal.spliceId,
+                spliceType: spliced.spliceType,
+                totalValue: spliced.totalValue.toString(),
+                balances: Object.fromEntries(Object.entries(spliced.balances).map(([partyId, amount]) => [partyId, amount.toString()])),
+                fundingCoinId: spliced.spliceFundingCoinId,
+            };
         });
     };
     register('totem_omniaSpliceIn', splice('in'), 'omnia/spliceIn');

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

@@ -16,6 +16,12 @@ export interface ConfirmationOptions {
 }
 export interface TotemNodeAdapter extends ChainStateProvider {
     getMode(): Promise<string | undefined>;
+    /**
+     * Sign arbitrary data with a wallet key (`sign publickey:<0x> data:<0x>`).
+     * Used to produce the funding witness signature: createChannel builds the
+     * funding digest, and this signs it with the funding coin's key.
+     */
+    signData(pubkeyHex: string, dataHex: string): Promise<string>;
     waitForConfirmation(coinId: string, options?: ConfirmationOptions): Promise<void>;
     subscribe(listener: (tip: ChainTip) => void): () => void;
     close(): void;

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

@@ -37,6 +37,10 @@ function createTotemNodeAdapter(options) {
         searchTokens: (query) => provider.searchTokens(query),
         getTokensByCreator: (address) => provider.getTokensByCreator(address),
         broadcastTxPoW: (txpowHex) => provider.broadcastTxPoW(txpowHex),
+        getMinTxPowWork: () => provider.getMinTxPowWork ? provider.getMinTxPowWork() : Promise.resolve(null),
+        ...(provider.submitTransaction
+            ? { submitTransaction: provider.submitTransaction.bind(provider) }
+            : {}),
         async getMode() {
             const result = await client.runCommand('getmode');
             if (!result || typeof result !== 'object')
@@ -44,6 +48,21 @@ function createTotemNodeAdapter(options) {
             const mode = result.mode;
             return typeof mode === 'string' ? mode : undefined;
         },
+        async signData(pubkeyHex, dataHex) {
+            const result = await client.runCommand('sign', { publickey: pubkeyHex, data: dataHex });
+            const unwrap = (v) => {
+                if (typeof v === 'string')
+                    return v;
+                if (v && typeof v === 'object' && typeof v.response === 'string') {
+                    return v.response;
+                }
+                return undefined;
+            };
+            const sig = unwrap(result) ?? unwrap(result?.response);
+            if (!sig)
+                throw new Error('signData: unexpected node response');
+            return sig;
+        },
         async waitForConfirmation(coinId, confirmationOptions = {}) {
             const timeoutMs = confirmationOptions.timeoutMs ?? 120_000;
             const interval = confirmationOptions.pollIntervalMs ?? pollIntervalMs;

package/dist/cli.js

@@ -16,6 +16,8 @@ async function main() {
         ? {
             signer: signing.signer,
             leaseProvider: signing.leaseProvider,
+            transportKeyPair: signing.transportKeyPair,
+            transportPubkey: signing.transportPubkey,
             identity: identityAndManifest?.identity
                 ? {
                     address: signing.address,

package/dist/config.d.ts

@@ -11,6 +11,12 @@ export interface OmniaHostConfig {
     localAddressIndex?: number;
     localSettlementAddress?: string;
     nodeMode?: string;
+    /**
+     * Public key (0x…) that owns the funding coin. When set, the host signs the
+     * funding-transaction digest via the node's `sign` command to assemble the
+     * channel funding witness (OMNIA_FUNDING_PUBKEY).
+     */
+    fundingPubkey?: string;
     wsPath: string;
     /** BIP39 mnemonic or hex seed (same formats @totemsdk/core accepts). */
     seed?: string;

package/dist/config.js

@@ -75,6 +75,7 @@ function loadConfigFromEnv(env = process.env) {
         localAddressIndex: optionalInteger(env.OMNIA_LOCAL_ADDRESS_INDEX),
         localSettlementAddress: optional(env.OMNIA_LOCAL_SETTLEMENT_ADDRESS),
         nodeMode: optional(env.OMNIA_NODE_MODE),
+        fundingPubkey: optional(env.OMNIA_FUNDING_PUBKEY),
         wsPath: env.OMNIA_WS_PATH?.trim() || '/rpc',
         seed,
         keyfile,

package/dist/identity.js

@@ -91,6 +91,7 @@ async function createHostManifest(config, signing, identity) {
         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'],
+        transportPubkey: signing.transportPubkey,
     };
     // RFC-037: sign the manifest with the unified child TreeKey. Allocate a
     // one-time leaf via the lease so restarts never reuse a WOTS leaf.

package/dist/lifecycle.d.ts

@@ -24,6 +24,13 @@ export interface OmniaHostDependencies {
     methods?: Map<string, JsonRpcHandler>;
     operationStoreForApi?: OperationStoreLike;
     localParticipant?: import('@totemsdk/omnia').ChannelParticipant;
+    /** Stable ed25519 native transport keypair (derived from the host seed). */
+    transportKeyPair?: {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    /** `0x`-prefixed transport public key published in the signed manifest. */
+    transportPubkey?: string;
     factories?: Map<string, ChannelFactory>;
     factoryBundles?: Record<string, WotsLeaseBundle>;
     spliceProposals?: Map<string, SpliceProposal>;

package/dist/lifecycle.js

@@ -8,6 +8,9 @@ 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");
+const reply_cache_js_1 = require("./reply-cache.js");
+const omnia_factory_1 = require("@totemsdk/omnia-factory");
+const omnia_splice_1 = require("@totemsdk/omnia-splice");
 /**
  * Phase-1 lifecycle shell. Subsystems will be attached in later phases while
  * preserving idempotent startup and shutdown for the CLI and embedding users.
@@ -54,9 +57,23 @@ function createOmniaHost(config, dependencies = {}) {
                 const relay = config.relay
                     ? { mode: 'self-hosted', relayUrl: config.relay }
                     : { mode: 'native' };
+                const dhtBootstrap = (process.env.OMNIA_DHT_BOOTSTRAP ?? '')
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                // Serverless native mode: bind/announce an explicit local interface so
+                // peers can reach us directly (multi-homed hosts, netns, VPN, etc.).
+                const dhtHost = process.env.OMNIA_DHT_HOST?.trim() || undefined;
+                const dhtPort = process.env.OMNIA_DHT_PORT
+                    ? Number(process.env.OMNIA_DHT_PORT)
+                    : undefined;
                 swarm = await (dependencies.createSwarm ?? omnia_1.createOmniaSwarm)({
                     localPubkey: config.localPubkey,
                     relay,
+                    ...(dhtBootstrap.length ? { bootstrap: dhtBootstrap } : {}),
+                    ...(dependencies.transportKeyPair ? { keyPair: dependencies.transportKeyPair } : {}),
+                    ...(dhtHost ? { host: dhtHost } : {}),
+                    ...(dhtPort ? { port: dhtPort } : {}),
                 });
             }
             if (!chainAdapter) {
@@ -76,10 +93,238 @@ function createOmniaHost(config, dependencies = {}) {
                     settlementAddress: config.localSettlementAddress,
                 }
                 : undefined);
+            // Factory managers default to this node's own lease bundle so the local
+            // side can propose/sign without extra wiring. A two-host factory still
+            // needs peer coordination (FACTORY_PROPOSAL/ACCEPT).
+            const factoryBundles = dependencies.factoryBundles ?? (localParticipant && dependencies.signer && dependencies.leaseProvider
+                ? {
+                    [localParticipant.partyId]: {
+                        signer: dependencies.signer,
+                        leaseProvider: dependencies.leaseProvider,
+                    },
+                }
+                : undefined);
+            const factories = dependencies.factories ?? (factoryBundles ? new Map() : undefined);
+            const localBundle = localParticipant
+                ? factoryBundles?.[localParticipant.partyId]
+                : undefined;
+            const spliceLeaseProvider = dependencies.spliceLeaseProvider ?? (dependencies.signer && dependencies.leaseProvider
+                ? {
+                    signer: dependencies.signer,
+                    wotsLease: dependencies.leaseProvider,
+                    ...(chainAdapter
+                        ? { broadcast: (txHex) => chainAdapter.broadcastTxPoW(txHex) }
+                        : {}),
+                }
+                : undefined);
+            const spliceProposals = dependencies.spliceProposals ?? new Map();
+            const spliceAcceptances = dependencies.spliceAcceptances ?? new Map();
+            const onSpliceMessage = async (peer, msg) => {
+                if (!spliceLeaseProvider || !channelStore)
+                    return;
+                if (msg?.type !== 'SPLICE_PROPOSAL' && msg?.type !== 'SPLICE_FINALIZED')
+                    return;
+                const payload = (msg.payload ?? {});
+                try {
+                    if (msg.type === 'SPLICE_PROPOSAL' && payload.proposal) {
+                        const proposal = payload.proposal;
+                        let channel = channelStore.get(proposal.channelId);
+                        if (!channel)
+                            throw new Error(`Splice channel ${proposal.channelId} not found`);
+                        const prior = spliceAcceptances.get(proposal.spliceId);
+                        if (prior) {
+                            await peer.sendMessage({
+                                type: 'SPLICE_ACCEPT',
+                                channelId: msg.channelId,
+                                nonce: msg.nonce,
+                                payload: { acceptance: prior },
+                            });
+                            return;
+                        }
+                        if (channel.status === 'active') {
+                            channel = await (0, omnia_splice_1.quiesceChannel)(channel, spliceLeaseProvider);
+                            channelStore.set(channel.channelId, channel);
+                        }
+                        const acceptance = await (0, omnia_splice_1.acceptSplice)(channel, proposal, spliceLeaseProvider);
+                        spliceAcceptances.set(proposal.spliceId, acceptance);
+                        await peer.sendMessage({
+                            type: 'SPLICE_ACCEPT',
+                            channelId: msg.channelId,
+                            nonce: msg.nonce,
+                            payload: { acceptance },
+                        });
+                        return;
+                    }
+                    if (msg.type === 'SPLICE_FINALIZED' && payload.channel) {
+                        const channel = payload.channel;
+                        channelStore.set(channel.channelId, channel);
+                        const acceptance = spliceAcceptances.get(payload.spliceId);
+                        if (acceptance && typeof payload.txId === 'string') {
+                            await spliceLeaseProvider.wotsLease
+                                .commitKeyUse(acceptance.acceptorReservationId, payload.txId)
+                                .catch(() => { });
+                        }
+                    }
+                }
+                catch (err) {
+                    await peer.sendMessage({
+                        type: 'ERROR',
+                        channelId: msg.channelId,
+                        nonce: msg.nonce,
+                        payload: { error: err instanceof Error ? err.message : String(err) },
+                    }).catch(() => { });
+                }
+            };
+            const factoryReplies = new reply_cache_js_1.ReplyCache();
+            const vcReplies = new reply_cache_js_1.ReplyCache();
+            const onFactoryMessage = async (peer, msg) => {
+                if (!factories || !localBundle)
+                    return;
+                if (msg?.type !== 'FACTORY_PROPOSAL' &&
+                    msg?.type !== 'FACTORY_FUNDING_REQUEST' &&
+                    msg?.type !== 'FACTORY_CLOSE_PROPOSAL' &&
+                    msg?.type !== 'FACTORY_CLOSE_FINALIZED')
+                    return;
+                const payload = (msg?.payload ?? {});
+                if (process.env.OMNIA_DEBUG) {
+                    console.error('[factory] recv', msg.type, 'hasFactory', !!payload.factory, 'bundles', !!localBundle);
+                }
+                const key = factoryReplies.key(msg.type, msg.channelId, msg.nonce);
+                const reply = await factoryReplies.run(key, async () => {
+                    try {
+                        if (msg.type === 'FACTORY_FUNDING_REQUEST' && typeof payload.digest === 'string') {
+                            const digest = Uint8Array.from(Buffer.from(payload.digest.replace(/^0x/i, ''), 'hex'));
+                            const reservation = await localBundle.leaseProvider.reserveKeyUse({
+                                treeId: 'factory-funding',
+                                purpose: 'factory-funding',
+                                payloadHash: payload.digest,
+                            });
+                            try {
+                                const signature = await localBundle.signer.sign(digest, reservation.indices);
+                                await localBundle.leaseProvider.commitKeyUse(reservation.reservationId, 'factory-funding');
+                                return {
+                                    type: 'FACTORY_FUNDING_RESPONSE',
+                                    channelId: msg.channelId,
+                                    nonce: msg.nonce,
+                                    payload: { signature: '0x' + Buffer.from(signature).toString('hex') },
+                                };
+                            }
+                            catch (err) {
+                                await localBundle.leaseProvider.burnReservation(reservation.reservationId, 'factory-funding-failed').catch(() => { });
+                                throw err;
+                            }
+                        }
+                        if (msg.type === 'FACTORY_PROPOSAL' && payload.factory) {
+                            const accepted = await (0, omnia_factory_1.acceptFactory)(payload.factory, localBundle);
+                            factories.set(accepted.factoryId, accepted);
+                            return {
+                                type: 'FACTORY_ACCEPT',
+                                channelId: accepted.factoryId,
+                                nonce: msg.nonce,
+                                payload: { factory: accepted },
+                            };
+                        }
+                        if (msg.type === 'FACTORY_CLOSE_PROPOSAL' && payload.factoryId) {
+                            const factory = factories.get(payload.factoryId);
+                            if (!factory)
+                                throw new Error(`Factory ${payload.factoryId} not found`);
+                            const signature = await (0, omnia_factory_1.signFactorySettlement)(factory, payload.draft, localBundle);
+                            await localBundle.leaseProvider
+                                .commitKeyUse(signature.reservationId, `factory-settlement-${payload.factoryId}`)
+                                .catch(() => { });
+                            return {
+                                type: 'FACTORY_CLOSE_ACCEPT',
+                                channelId: payload.factoryId,
+                                nonce: msg.nonce,
+                                payload: { signature },
+                            };
+                        }
+                        if (msg.type === 'FACTORY_CLOSE_FINALIZED' && payload.factoryId) {
+                            const factory = factories.get(payload.factoryId);
+                            if (factory)
+                                factories.set(payload.factoryId, { ...factory, status: 'closed' });
+                            return null;
+                        }
+                        return null;
+                    }
+                    catch (e) {
+                        if (process.env.OMNIA_DEBUG)
+                            console.error('[factory] err', String(e));
+                        return {
+                            type: 'ERROR',
+                            channelId: msg.channelId,
+                            nonce: msg.nonce,
+                            payload: { error: String(e) },
+                        };
+                    }
+                });
+                if (reply)
+                    await peer.sendMessage(reply);
+            };
+            const onVcMessage = async (peer, msg) => {
+                if (!factories || !localBundle)
+                    return;
+                const payload = (msg?.payload ?? {});
+                if (msg?.type === 'VC_FINALIZED') {
+                    if (payload.factory)
+                        factories.set(payload.factory.factoryId, payload.factory);
+                    if (payload.kind === 'vc-open' && payload.channel) {
+                        channelStore?.set(payload.channel.channelId, payload.channel);
+                    }
+                    else if (payload.kind === 'vc-close' && payload.channelId) {
+                        channelStore?.delete(payload.channelId);
+                    }
+                    return;
+                }
+                if (msg?.type !== 'VC_PROPOSAL')
+                    return;
+                const key = vcReplies.key(msg.type, msg.channelId, msg.nonce, payload.kind);
+                const reply = await vcReplies.run(key, async () => {
+                    try {
+                        const factory = factories.get(payload.factoryId);
+                        if (!factory)
+                            throw new Error(`Factory ${payload.factoryId} not found`);
+                        if (payload.kind === 'vc-open') {
+                            const signature = await (0, omnia_factory_1.signVirtualChannelOpen)(factory, payload.plan, localBundle);
+                            await localBundle.leaseProvider.commitKeyUse(signature.reservationId, `factory-vc-open-${payload.factoryId}`);
+                            return {
+                                type: 'VC_ACCEPT',
+                                channelId: payload.vcId,
+                                nonce: msg.nonce,
+                                payload: { kind: 'vc-open', signature },
+                            };
+                        }
+                        if (payload.kind === 'vc-close') {
+                            const signature = await (0, omnia_factory_1.signVirtualChannelClose)(factory, payload.plan, localBundle);
+                            await localBundle.leaseProvider.commitKeyUse(signature.reservationId, `factory-vc-close-${payload.factoryId}`);
+                            return {
+                                type: 'VC_ACCEPT',
+                                channelId: payload.vcId,
+                                nonce: msg.nonce,
+                                payload: { kind: 'vc-close', signature },
+                            };
+                        }
+                        return null;
+                    }
+                    catch (e) {
+                        return {
+                            type: 'ERROR',
+                            channelId: msg.channelId,
+                            nonce: msg.nonce,
+                            payload: { error: String(e) },
+                        };
+                    }
+                });
+                if (reply)
+                    await peer.sendMessage(reply);
+            };
             unsubscribe = (0, omnia_1.createOmniaIntegration)(swarm, channelStore, {
                 signer: dependencies.signer,
                 leaseProvider: dependencies.leaseProvider,
                 chainProvider: dependencies.chainProvider ?? chainAdapter,
+                onFactoryMessage,
+                onVcMessage,
+                onSpliceMessage,
             });
             if (!controlServer) {
                 const readOnly = !dependencies.signer || !dependencies.leaseProvider;
@@ -102,11 +347,18 @@ function createOmniaHost(config, dependencies = {}) {
                         chainProvider: dependencies.chainProvider ?? chainAdapter,
                         swarm,
                         localParticipant,
-                        factories: dependencies.factories,
-                        factoryBundles: dependencies.factoryBundles,
-                        spliceProposals: dependencies.spliceProposals,
-                        spliceAcceptances: dependencies.spliceAcceptances,
-                        spliceLeaseProvider: dependencies.spliceLeaseProvider,
+                        transportPubkey: dependencies.transportPubkey,
+                        factories,
+                        factoryBundles,
+                        spliceProposals,
+                        spliceAcceptances,
+                        spliceLeaseProvider,
+                        fundingSigner: config.fundingPubkey
+                            ? async (digest) => {
+                                const sig = await chainAdapter.signData(config.fundingPubkey, '0x' + Buffer.from(digest).toString('hex'));
+                                return Uint8Array.from(Buffer.from(sig.replace(/^0x/i, ''), 'hex'));
+                            }
+                            : undefined,
                         readOnly,
                         identity: dependencies.identity,
                         manifest: dependencies.manifest,

package/dist/reply-cache.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Idempotent request/reply support for peer proposals.
+ *
+ * A requester resends a proposal when the transport reconnects (the proposal or
+ * its reply may have been lost). The responder must then:
+ *   - never sign/allocate a second time for the same logical request, and
+ *   - return the exact same reply so the requester sees a consistent result.
+ *
+ * Keyed by `(type, kind, channelId, nonce)`; concurrent duplicates await the
+ * in-flight execution instead of starting a second one.
+ */
+export declare class ReplyCache {
+    private readonly _maxEntries;
+    private readonly _ttlMs;
+    private readonly _replies;
+    private readonly _inFlight;
+    constructor(_maxEntries?: number, _ttlMs?: number);
+    key(type: string, channelId: string, nonce: number | undefined, kind?: string): string;
+    run<T>(key: string, fn: () => Promise<T | null>): Promise<T | null>;
+    private _evict;
+}

package/dist/reply-cache.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplyCache = void 0;
+/**
+ * Idempotent request/reply support for peer proposals.
+ *
+ * A requester resends a proposal when the transport reconnects (the proposal or
+ * its reply may have been lost). The responder must then:
+ *   - never sign/allocate a second time for the same logical request, and
+ *   - return the exact same reply so the requester sees a consistent result.
+ *
+ * Keyed by `(type, kind, channelId, nonce)`; concurrent duplicates await the
+ * in-flight execution instead of starting a second one.
+ */
+class ReplyCache {
+    _maxEntries;
+    _ttlMs;
+    _replies = new Map();
+    _inFlight = new Map();
+    constructor(_maxEntries = 512, _ttlMs = 10 * 60_000) {
+        this._maxEntries = _maxEntries;
+        this._ttlMs = _ttlMs;
+    }
+    key(type, channelId, nonce, kind) {
+        return [type, kind ?? '', channelId, nonce ?? ''].join(':');
+    }
+    async run(key, fn) {
+        const cached = this._replies.get(key);
+        if (cached) {
+            if (Date.now() - cached.at < this._ttlMs)
+                return cached.reply;
+            this._replies.delete(key);
+        }
+        const inFlight = this._inFlight.get(key);
+        if (inFlight)
+            return inFlight;
+        const promise = (async () => {
+            try {
+                const reply = await fn();
+                if (reply !== null) {
+                    this._replies.set(key, { reply, at: Date.now() });
+                    this._evict();
+                }
+                return reply;
+            }
+            finally {
+                this._inFlight.delete(key);
+            }
+        })();
+        this._inFlight.set(key, promise);
+        return promise;
+    }
+    _evict() {
+        while (this._replies.size > this._maxEntries) {
+            const oldest = this._replies.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this._replies.delete(oldest);
+        }
+    }
+}
+exports.ReplyCache = ReplyCache;

package/dist/signing.d.ts

@@ -24,6 +24,17 @@ import type { OmniaHostConfig } from './config.js';
 export interface HostSigning {
     signer: ChannelSigner;
     leaseProvider: WotsLeaseProvider;
+    /**
+     * Stable ed25519 keypair used as the native Hyperswarm transport identity.
+     * Derived deterministically from the host seed. The transport is classical
+     * (noise); its public key is bound to the PQ identity by the signed manifest.
+     */
+    transportKeyPair: {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    /** `0x`-prefixed hex transport public key (published in the signed manifest). */
+    transportPubkey: string;
     /** Minima address for the unified child TreeKey (identity + channels). */
     address: string;
     /** Channel participant key: the unified child TreeKey root pubkey (RFC-037). */

package/dist/signing.js

@@ -79,6 +79,29 @@ function encryptSeedForKeyfile(seed, passphrase) {
         authTag: cipher.getAuthTag().toString('hex'),
     };
 }
+/**
+ * Derive the stable ed25519 transport keypair from the host seed.
+ *
+ * The transport is Hyperswarm's classical noise channel; this key is *not* the
+ * quantum-resistant identity. It is published in the identity-signed manifest
+ * so peers can bind it to the host's PQ identity.
+ */
+function deriveTransportKeyPair(baseSeed) {
+    const seed = (0, node_crypto_1.createHash)('sha256')
+        .update(Buffer.concat([Buffer.from(baseSeed), Buffer.from('omnia-transport-v1')]))
+        .digest();
+    // Ed25519 PKCS#8 DER prefix + 32-byte seed
+    const pkcs8 = Buffer.concat([
+        Buffer.from('302e020100300506032b657004220420', 'hex'),
+        seed,
+    ]);
+    const privateKey = (0, node_crypto_1.createPrivateKey)({ key: pkcs8, format: 'der', type: 'pkcs8' });
+    const spki = (0, node_crypto_1.createPublicKey)(privateKey).export({ format: 'der', type: 'spki' });
+    const publicKey = spki.subarray(spki.length - 32);
+    // sodium/ed25519 64-byte secret key = seed || publicKey
+    const secretKey = Buffer.concat([seed, publicKey]);
+    return { publicKey: new Uint8Array(publicKey), secretKey: new Uint8Array(secretKey) };
+}
 function resolveBaseSeed(config) {
     if (config.seed) {
         const trimmed = config.seed.trim();
@@ -194,11 +217,15 @@ function createHostSigning(config) {
             return (0, core_1.serializeTreeSignature)(treeKey.sign(payload));
         },
     };
+    const transportKeyPair = deriveTransportKeyPair(baseSeed);
+    const transportPubkey = `0x${(0, core_1.bytesToHex)(transportKeyPair.publicKey)}`;
     return {
         signer,
         leaseProvider,
         address,
         publicKeyDigest,
+        transportKeyPair,
+        transportPubkey,
         baseSeed,
         treeKey,
         addressIndex,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/omnia-host",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Durable Omnia node daemon for channel lifecycle, routing, and control APIs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,17 +22,17 @@
   "dependencies": {
     "better-sqlite3": "^12.2.0",
     "ws": "^8.21.1",
-    "@totemsdk/chain-provider": "^0.2.1",
-    "@totemsdk/identity": "^1.0.1",
-    "@totemsdk/core": "^1.2.11",
-    "@totemsdk/manifest": "^2.0.0",
-    "@totemsdk/omnia": "^2.0.1",
-    "@totemsdk/omnia-factory": "^0.5.0",
-    "@totemsdk/omnia-router": "^0.3.0",
+    "@totemsdk/chain-provider": "^0.3.0",
+    "@totemsdk/core": "^1.4.0",
+    "@totemsdk/identity": "^1.0.2",
+    "@totemsdk/manifest": "^2.0.1",
+    "@totemsdk/omnia": "^2.3.0",
+    "@totemsdk/omnia-factory": "^0.7.0",
+    "@totemsdk/omnia-router": "^0.4.0",
     "@totemsdk/omnia-splice": "^0.3.0",
-    "@totemsdk/omnia-vtxo": "^0.5.0",
-    "@totemsdk/minima-rpc": "^0.2.2",
     "@totemsdk/storage": "^0.1.0",
+    "@totemsdk/omnia-vtxo": "^0.6.1",
+    "@totemsdk/minima-rpc": "^0.4.0",
     "@totemsdk/wots-lease": "^1.0.1"
   },
   "devDependencies": {
@@ -43,7 +43,7 @@
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11",
     "typescript": "5.9.3",
-    "@totemsdk/txpow": "^1.0.2"
+    "@totemsdk/txpow": "^1.1.0"
   },
   "engines": {
     "node": ">=20.0.0"