@totemsdk/omnia-host 0.10.0 → 0.11.0

package/dist/api/methods.js

@@ -4,9 +4,13 @@ exports.channelStateView = channelStateView;
 exports.requestPeerReply = requestPeerReply;
 exports.createHostMethods = createHostMethods;
 const omnia_1 = require("@totemsdk/omnia");
+const omnia_vtxo_1 = require("@totemsdk/omnia-vtxo");
+const omnia_pool_1 = require("@totemsdk/omnia-pool");
+const liquidity_bond_1 = require("@totemsdk/liquidity-bond");
 const omnia_router_1 = require("@totemsdk/omnia-router");
 const omnia_factory_1 = require("@totemsdk/omnia-factory");
 const omnia_splice_1 = require("@totemsdk/omnia-splice");
+const emitter_js_1 = require("../observe/emitter.js");
 function channelSummary(channel) {
     const parties = channel.parties.map((party) => party.partyId);
     return {
@@ -149,16 +153,36 @@ async function withOperation(context, params, run) {
     if (existing && !['pending', 'failed'].includes(existing.status)) {
         throw new Error(`Operation ${id} is already ${existing.status}`);
     }
-    if (!existing)
+    if (!existing) {
         context.operations.create(id, params);
+        await context.observe?.emit({
+            domain: 'operation', kind: 'operation.created', phase: 'proposed',
+            entity: { type: 'operation', id }, operationId: id,
+            data: { request: params },
+        });
+    }
     context.operations.transition(id, existing?.status === 'failed' ? 'failed' : 'pending', 'executing');
+    await context.observe?.emit({
+        domain: 'operation', kind: 'operation.executing', phase: 'executing',
+        entity: { type: 'operation', id }, operationId: id,
+    });
     try {
         const result = await run();
         context.operations.transition(id, 'executing', 'committed', { result });
+        await context.observe?.emit({
+            domain: 'operation', kind: 'operation.committed', phase: 'committed',
+            entity: { type: 'operation', id }, operationId: id,
+            data: { result },
+        });
         return result;
     }
     catch (error) {
         context.operations.transition(id, 'executing', 'failed', { error: error instanceof Error ? error.message : String(error) });
+        await context.observe?.emit({
+            domain: 'operation', kind: 'operation.failed', phase: 'failed',
+            entity: { type: 'operation', id }, operationId: id,
+            data: { error: error instanceof Error ? error.message : String(error) },
+        });
         throw error;
     }
 }
@@ -238,12 +262,1397 @@ function requestPeerReply(peer, msg, channelId, timeoutMs, types = ['ACK', 'ERRO
         void peer.sendMessage(msg).catch(() => { });
     });
 }
+function signingIndicesParam(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('signingIndices is required');
+    const item = value;
+    const num = (key) => {
+        const parsed = Number(item[key]);
+        if (!Number.isInteger(parsed) || parsed < 0)
+            throw new Error(`signingIndices.${key} must be a non-negative integer`);
+        return parsed;
+    };
+    return { addressIndex: num('addressIndex'), l1: num('l1'), l2: num('l2') };
+}
+function hexBytes(value, label) {
+    if (typeof value !== 'string')
+        throw new Error(`${label} must be a hex string`);
+    return Buffer.from(value.replace(/^0x/i, ''), 'hex');
+}
+function registerPreparedPayMethods(methods, context) {
+    const preparePay = async (raw) => {
+        const params = paramsObject(raw);
+        const channelId = requiredString(params, 'channelId');
+        const amount = requiredBigInt(params, 'amount');
+        const localPartyId = context.localParticipant?.partyId;
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPartyId || !localPkd)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedPay)
+            throw new Error('Prepared-pay store is not configured');
+        const channel = context.channels.get(channelId);
+        if (!channel)
+            throw new Error(`Channel ${channelId} not found`);
+        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');
+        }
+        if ((context.custodyMode ?? 'self') === 'hosted') {
+            throw new Error('preparePay requires an explicit hosted custody disclosure context (not yet configured)');
+        }
+        return withOperation(context, params, async () => {
+            const preparedOperationId = operationId(params);
+            const unsigned = (0, omnia_1.buildStateUpdate)(channel, {
+                newSequence: channel.currentSequence + 1,
+                newBalances: {
+                    ...channel.balances,
+                    [localPartyId]: (channel.balances[localPartyId] ?? 0n) - amount,
+                    [remotePartyId]: (channel.balances[remotePartyId] ?? 0n) + amount,
+                },
+            }, { publicKeyDigest: localPkd });
+            const expiresAt = Date.now() + 120_000;
+            const base = {
+                domain: 'channel',
+                signers: [localPkd],
+                custody: (0, omnia_1.makeSelfCustody)(),
+                expiresAt,
+            };
+            const intent = {
+                ...base,
+                requestId: `${preparedOperationId}:intent`,
+                kind: 'intent',
+                digest: unsigned.updateDigest,
+                context: { summary: `Authorize payment of ${amount.toString()} on channel ${channelId}` },
+            };
+            const update = {
+                ...base,
+                requestId: `${preparedOperationId}:update`,
+                kind: 'chain',
+                digest: unsigned.updateDigest,
+                context: { summary: 'Sign the channel update transaction' },
+            };
+            const settlement = {
+                ...base,
+                requestId: `${preparedOperationId}:settlement`,
+                kind: 'chain',
+                digest: unsigned.settlementDigest,
+                context: { summary: 'Sign the settlement close package' },
+            };
+            for (const [key, entry] of context.preparedPay) {
+                if (entry.expiresAt <= Date.now())
+                    context.preparedPay.delete(key);
+            }
+            context.preparedPay.set(preparedOperationId, { channelId, unsigned, intent, update, settlement, expiresAt });
+            return {
+                success: true,
+                status: 'signature-required',
+                operationId: preparedOperationId,
+                channelId,
+                requests: { intent, update, settlement },
+                expiresAt,
+            };
+        });
+    };
+    methods.set('totem_omniaPreparePay', preparePay);
+    methods.set('omnia/preparePay', preparePay);
+    const prepareChannelUpdate = async (raw) => {
+        const params = paramsObject(raw);
+        const channelId = requiredString(params, 'channelId');
+        const localPartyId = context.localParticipant?.partyId;
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPartyId || !localPkd)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedPay)
+            throw new Error('Prepared-pay store is not configured');
+        const channel = context.channels.get(channelId);
+        if (!channel)
+            throw new Error(`Channel ${channelId} not found`);
+        if ((context.custodyMode ?? 'self') === 'hosted') {
+            throw new Error('prepareChannelUpdate requires an explicit hosted custody disclosure context (not yet configured)');
+        }
+        const rawBalances = params.newBalances;
+        const newBalances = rawBalances && typeof rawBalances === 'object'
+            ? Object.fromEntries(Object.entries(rawBalances).map(([partyId, value]) => [partyId, BigInt(String(value))]))
+            : channel.balances;
+        const programTransition = params.programTransition;
+        return withOperation(context, params, async () => {
+            const preparedOperationId = operationId(params);
+            const unsigned = (0, omnia_1.buildStateUpdate)(channel, { newSequence: channel.currentSequence + 1, newBalances, programTransition }, { publicKeyDigest: localPkd });
+            const expiresAt = Date.now() + 120_000;
+            const base = {
+                domain: 'channel',
+                signers: [localPkd],
+                custody: (0, omnia_1.makeSelfCustody)(),
+                expiresAt,
+            };
+            const summary = typeof params.memo === 'string' && params.memo ? params.memo : 'Channel state update';
+            const intent = {
+                ...base,
+                requestId: `${preparedOperationId}:intent`,
+                kind: 'intent',
+                digest: unsigned.updateDigest,
+                context: { summary: `Authorize ${summary}` },
+            };
+            const update = {
+                ...base,
+                requestId: `${preparedOperationId}:update`,
+                kind: 'chain',
+                digest: unsigned.updateDigest,
+                context: { summary: 'Sign the channel update transaction' },
+            };
+            const settlement = {
+                ...base,
+                requestId: `${preparedOperationId}:settlement`,
+                kind: 'chain',
+                digest: unsigned.settlementDigest,
+                context: { summary: 'Sign the settlement close package' },
+            };
+            for (const [key, entry] of context.preparedPay) {
+                if (entry.expiresAt <= Date.now())
+                    context.preparedPay.delete(key);
+            }
+            context.preparedPay.set(preparedOperationId, { channelId, unsigned, intent, update, settlement, expiresAt });
+            return {
+                success: true,
+                status: 'signature-required',
+                operationId: preparedOperationId,
+                channelId,
+                requests: { intent, update, settlement },
+                expiresAt,
+            };
+        });
+    };
+    methods.set('totem_omniaPrepareChannelUpdate', prepareChannelUpdate);
+    methods.set('omnia/prepareChannelUpdate', prepareChannelUpdate);
+    const submitPay = async (raw) => {
+        const params = paramsObject(raw);
+        const preparedOperationId = requiredString(params, 'preparedOperationId');
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPkd)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedPay)
+            throw new Error('Prepared-pay store is not configured');
+        return withOperation(context, params, async () => {
+            const entry = context.preparedPay.get(preparedOperationId);
+            if (!entry)
+                throw new Error(`Prepared payment ${preparedOperationId} not found`);
+            if (entry.expiresAt <= Date.now()) {
+                context.preparedPay.delete(preparedOperationId);
+                throw new Error(`Prepared payment ${preparedOperationId} has expired`);
+            }
+            const intentSignature = hexBytes(params.intentSignature, 'intentSignature');
+            const updateSignature = hexBytes(params.updateSignature, 'updateSignature');
+            const settlementSignature = hexBytes(params.settlementSignature, 'settlementSignature');
+            const updateIndices = signingIndicesParam(params.updateIndices);
+            const settlementIndices = signingIndicesParam(params.settlementIndices);
+            if (!(0, omnia_1.verifyChannelSignature)(intentSignature, (0, omnia_1.signRequestPayload)(entry.intent), localPkd)) {
+                throw new Error('intent signature does not verify');
+            }
+            if (!(0, omnia_1.verifyChannelSignature)(updateSignature, entry.unsigned.updateDigest, localPkd)) {
+                throw new Error('update signature does not verify');
+            }
+            if (!(0, omnia_1.verifyChannelSignature)(settlementSignature, entry.unsigned.settlementDigest, localPkd)) {
+                throw new Error('settlement signature does not verify');
+            }
+            const state = (0, omnia_1.finalizeStateUpdateWithIndices)(entry.unsigned, updateSignature, updateIndices, settlementSignature, settlementIndices);
+            const channel = entry.unsigned.channel;
+            const updatedChannel = {
+                ...channel,
+                balances: state.balances,
+                currentSequence: state.sequence,
+                pendingProposal: { sequence: state.sequence, payloadHash: entry.unsigned.payloadHash },
+                stateLog: [
+                    ...channel.stateLog,
+                    {
+                        sequence: state.sequence,
+                        timestamp: Date.now(),
+                        balances: { ...state.balances },
+                        htlcCount: entry.unsigned.pendingHTLCs.length,
+                        event: 'update',
+                    },
+                ],
+                updatedAt: Date.now(),
+            };
+            context.channels.set(entry.channelId, updatedChannel);
+            const localPartyId = context.localParticipant.partyId;
+            const remote = channel.parties.find((party) => party.partyId !== localPartyId);
+            if (!remote)
+                throw new Error('Channel counterparty not found');
+            if (context.swarm) {
+                const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, entry.channelId, remote.transportPubkey);
+                await peer.sendMessage({
+                    type: 'STATE_UPDATE',
+                    channelId: entry.channelId,
+                    nonce: Date.now(),
+                    payload: state,
+                });
+            }
+            context.preparedPay.delete(preparedOperationId);
+            return {
+                success: true,
+                channelId: entry.channelId,
+                sequence: state.sequence,
+                localBalance: state.balances[localPartyId].toString(),
+                remoteBalance: state.balances[remote.partyId].toString(),
+            };
+        });
+    };
+    methods.set('totem_omniaSubmitPay', submitPay);
+    methods.set('omnia/submitPay', submitPay);
+    methods.set('totem_omniaSubmitChannelUpdate', submitPay);
+    methods.set('omnia/submitChannelUpdate', submitPay);
+    const prepareSettle = async (raw) => {
+        const params = paramsObject(raw);
+        const channelId = requiredString(params, 'channelId');
+        const localPartyId = context.localParticipant?.partyId;
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPartyId || !localPkd)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedSettle)
+            throw new Error('Prepared-settle store is not configured');
+        if (!context.swarm)
+            throw new Error('prepareSettle requires swarm connectivity');
+        const channel = context.channels.get(channelId);
+        if (!channel)
+            throw new Error(`Channel ${channelId} not found`);
+        if (!['active', 'closing_mutual'].includes(channel.status)) {
+            throw new Error(`Channel ${channelId} is not settleable (${channel.status})`);
+        }
+        const closing = (0, omnia_1.markChannelClosing)(channel, 'mutual');
+        const partyAddresses = Object.fromEntries(closing.parties.map((party) => [party.partyId, party.settlementAddress ?? party.publicKeyDigest]));
+        const remote = closing.parties.find((party) => party.partyId !== localPartyId);
+        if (!remote)
+            throw new Error('Channel counterparty not found');
+        const request = (0, omnia_1.buildSettlementSigningRequest)(closing, { partyAddresses });
+        return withOperation(context, params, async () => {
+            const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, channelId, remote.transportPubkey);
+            const reply = await requestPeerReply(peer, {
+                type: 'SETTLEMENT_PROPOSAL',
+                channelId,
+                nonce: Date.now(),
+                payload: { signRequest: true, ...request },
+            }, channelId, 30_000);
+            const payload = reply?.payload;
+            if (reply?.type !== 'ACK' || typeof payload?.signature !== 'string') {
+                throw new Error(`Counterparty did not co-sign the settlement (${reply?.type ?? 'timeout'})`);
+            }
+            const counterpartySignature = {
+                partyId: payload.partyId ?? remote.partyId,
+                signature: Buffer.from(payload.signature.replace(/^0x/i, ''), 'hex'),
+            };
+            const preparedOperationId = operationId(params);
+            const expiresAt = Date.now() + 120_000;
+            const digest = Buffer.from(request.digestHex.replace(/^0x/i, ''), 'hex');
+            const base = {
+                domain: 'channel',
+                signers: [localPkd],
+                custody: (0, omnia_1.makeSelfCustody)(),
+                expiresAt,
+            };
+            const intent = {
+                ...base,
+                requestId: `${preparedOperationId}:intent`,
+                kind: 'intent',
+                digest,
+                context: { summary: 'Authorize cooperative settlement' },
+            };
+            const settlement = {
+                ...base,
+                requestId: `${preparedOperationId}:settlement`,
+                kind: 'chain',
+                digest,
+                context: { summary: 'Sign the cooperative settlement transaction' },
+            };
+            for (const [key, entry] of context.preparedSettle) {
+                if (entry.expiresAt <= Date.now())
+                    context.preparedSettle.delete(key);
+            }
+            context.preparedSettle.set(preparedOperationId, {
+                channelId,
+                closing,
+                request,
+                counterpartySignature,
+                intent,
+                settlement,
+                expiresAt,
+            });
+            return {
+                success: true,
+                status: 'signature-required',
+                operationId: preparedOperationId,
+                channelId,
+                requests: { intent, settlement },
+                expiresAt,
+            };
+        });
+    };
+    methods.set('totem_omniaPrepareSettle', prepareSettle);
+    methods.set('omnia/prepareSettle', prepareSettle);
+    const submitSettle = async (raw) => {
+        const params = paramsObject(raw);
+        const preparedOperationId = requiredString(params, 'preparedOperationId');
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPkd)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedSettle)
+            throw new Error('Prepared-settle store is not configured');
+        return withOperation(context, params, async () => {
+            const entry = context.preparedSettle.get(preparedOperationId);
+            if (!entry)
+                throw new Error(`Prepared settlement ${preparedOperationId} not found`);
+            if (entry.expiresAt <= Date.now()) {
+                context.preparedSettle.delete(preparedOperationId);
+                throw new Error(`Prepared settlement ${preparedOperationId} has expired`);
+            }
+            const intentSignature = hexBytes(params.intentSignature, 'intentSignature');
+            const settlementSignature = hexBytes(params.settlementSignature, 'settlementSignature');
+            const digest = Buffer.from(entry.request.digestHex.replace(/^0x/i, ''), 'hex');
+            if (!(0, omnia_1.verifyChannelSignature)(intentSignature, (0, omnia_1.signRequestPayload)(entry.intent), localPkd)) {
+                throw new Error('intent signature does not verify');
+            }
+            if (!(0, omnia_1.verifyChannelSignature)(settlementSignature, digest, localPkd)) {
+                throw new Error('settlement signature does not verify');
+            }
+            if (!context.chainProvider)
+                throw new Error('Settlement requires a chain provider');
+            const rawProofs = params.broadcastProofs;
+            const broadcastProofs = rawProofs && typeof rawProofs === 'object'
+                && Array.isArray(rawProofs.coinProofs)
+                && Array.isArray(rawProofs.scriptProofs)
+                ? {
+                    coinProofs: rawProofs.coinProofs.map((hex) => Buffer.from(String(hex).replace(/^0x/i, ''), 'hex')),
+                    scriptProofs: rawProofs.scriptProofs.map((hex) => Buffer.from(String(hex).replace(/^0x/i, ''), 'hex')),
+                }
+                : undefined;
+            const settlementIndices = params.settlementIndices
+                ? signingIndicesParam(params.settlementIndices)
+                : undefined;
+            const settlement = await (0, omnia_1.proposeSettlement)(entry.closing, context.leaseProvider, {
+                chainProvider: context.chainProvider,
+                broadcastProofs,
+                partyAddresses: entry.request.partyAddresses,
+                settlementTxHex: entry.request.settlementTxHex,
+                counterpartySignatures: [entry.counterpartySignature],
+                localSignature: settlementSignature,
+                localIndices: settlementIndices,
+                localPartyId: context.localParticipant.partyId,
+            });
+            context.channels.set(entry.channelId, (0, omnia_1.markChannelClosed)(entry.closing));
+            context.preparedSettle.delete(preparedOperationId);
+            return {
+                success: true,
+                channelId: entry.channelId,
+                settlementTxId: settlement.settlementPayload.txpowId,
+                finalBalances: Object.fromEntries(Object.entries(settlement.settlementPayload.balances).map(([key, value]) => [key, value.toString()])),
+            };
+        });
+    };
+    methods.set('totem_omniaSubmitSettle', submitSettle);
+    methods.set('omnia/submitSettle', submitSettle);
+    const prepareOpenChannel = async (raw) => {
+        const params = paramsObject(raw);
+        const localParticipant = context.localParticipant;
+        const localPkd = localParticipant?.publicKeyDigest;
+        if (!localParticipant || !localPkd)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedOpen)
+            throw new Error('Prepared-open store is not configured');
+        if (!context.chainProvider)
+            throw new Error('prepareOpenChannel requires a chain provider');
+        const remote = {
+            partyId: requiredString(params, 'remotePartyId'),
+            publicKeyDigest: requiredString(params, '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 createParams = {
+            localParty: {
+                ...localParticipant,
+                transportPubkey: 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'),
+            contestDelayBlocks: typeof params.contestDelayBlocks === 'number' ? params.contestDelayBlocks : undefined,
+            fundingScript: typeof params.fundingScript === 'string' ? params.fundingScript : undefined,
+        };
+        return withOperation(context, params, async () => {
+            const plan = await (0, omnia_1.buildChannelOpening)(createParams, context.chainProvider);
+            const preparedOperationId = operationId(params);
+            const expiresAt = Date.now() + 300_000;
+            const base = {
+                domain: 'channel',
+                signers: [localPkd],
+                custody: (0, omnia_1.makeSelfCustody)(),
+                expiresAt,
+            };
+            const summary = `Open channel ${plan.channel.channelId} (${plan.channel.totalValue} units)`;
+            const intent = {
+                ...base,
+                requestId: `${preparedOperationId}:intent`,
+                kind: 'intent',
+                digest: plan.fundingDigest,
+                context: {
+                    summary: `Authorize ${summary}`,
+                    amount: plan.channel.totalValue.toString(),
+                    asset: plan.channel.tokenId,
+                    terms: `Counterparty ${remote.partyId}; channel ${plan.channel.channelId}`,
+                },
+            };
+            const funding = {
+                ...base,
+                requestId: `${preparedOperationId}:funding`,
+                kind: 'chain',
+                digest: plan.fundingDigest,
+                context: { summary: 'Sign the channel funding transaction' },
+            };
+            for (const [key, entry] of context.preparedOpen) {
+                if (entry.expiresAt <= Date.now())
+                    context.preparedOpen.delete(key);
+            }
+            context.preparedOpen.set(preparedOperationId, {
+                plan,
+                fundingScript: createParams.fundingScript,
+                intent,
+                funding,
+                expiresAt,
+            });
+            return {
+                success: true,
+                status: 'signature-required',
+                operationId: preparedOperationId,
+                channelId: plan.channel.channelId,
+                fundingAddress: plan.fundingAddress,
+                fundingCoinId: plan.outputCoinId,
+                inputCoinId: plan.inputCoinId,
+                totalValue: plan.channel.totalValue.toString(),
+                requests: { intent, funding },
+                expiresAt,
+            };
+        });
+    };
+    methods.set('totem_omniaPrepareOpenChannel', prepareOpenChannel);
+    methods.set('omnia/prepareOpenChannel', prepareOpenChannel);
+    const submitOpenChannel = async (raw) => {
+        const params = paramsObject(raw);
+        const preparedOperationId = requiredString(params, 'preparedOperationId');
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPkd)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedOpen)
+            throw new Error('Prepared-open store is not configured');
+        if (!context.chainProvider)
+            throw new Error('submitOpenChannel requires a chain provider');
+        return withOperation(context, params, async () => {
+            const entry = context.preparedOpen.get(preparedOperationId);
+            if (!entry)
+                throw new Error(`Prepared channel opening ${preparedOperationId} not found`);
+            if (entry.expiresAt <= Date.now()) {
+                context.preparedOpen.delete(preparedOperationId);
+                throw new Error(`Prepared channel opening ${preparedOperationId} has expired`);
+            }
+            const intentSignature = hexBytes(params.intentSignature, 'intentSignature');
+            const fundingSignature = hexBytes(params.fundingSignature, 'fundingSignature');
+            if (!(0, omnia_1.verifyChannelSignature)(intentSignature, (0, omnia_1.signRequestPayload)(entry.intent), localPkd)) {
+                throw new Error('intent signature does not verify');
+            }
+            if (!(0, omnia_1.verifyChannelSignature)(fundingSignature, entry.plan.fundingDigest, localPkd)) {
+                throw new Error('funding signature does not verify');
+            }
+            const toBytes = (value) => Array.isArray(value) ? value.map((item) => Buffer.from(String(item).replace(/^0x/i, ''), 'hex')) : [];
+            const fundingWitnessHex = typeof params.fundingWitnessHex === 'string' ? params.fundingWitnessHex : undefined;
+            let finalizeOpts;
+            if (fundingWitnessHex) {
+                finalizeOpts = { fundingWitnessBytes: Buffer.from(fundingWitnessHex.replace(/^0x/i, ''), 'hex') };
+            }
+            else {
+                finalizeOpts = {
+                    fundingSignature,
+                    fundingProofs: {
+                        coinProofs: toBytes(params.fundingCoinProofsHex),
+                        scriptProofs: toBytes(params.fundingScriptProofsHex),
+                    },
+                    fundingScript: typeof params.fundingScript === 'string'
+                        ? params.fundingScript
+                        : entry.fundingScript,
+                };
+            }
+            const { channel, proposal, fundingTxId } = await (0, omnia_1.finalizeChannelOpening)(entry.plan, finalizeOpts, context.chainProvider);
+            context.channels.set(channel.channelId, { ...channel, localSigner: context.signer });
+            let acknowledged = true;
+            if (context.swarm) {
+                const remote = channel.parties.find((party) => party.partyId !== context.localParticipant.partyId);
+                if (remote) {
+                    const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, channel.channelId, remote.transportPubkey);
+                    const reply = await requestPeerReply(peer, { type: 'CHANNEL_PROPOSAL', channelId: channel.channelId, nonce: Date.now(), payload: proposal }, channel.channelId, 20_000);
+                    acknowledged = reply?.type === 'ACK';
+                }
+            }
+            context.preparedOpen.delete(preparedOperationId);
+            return { success: true, channelId: channel.channelId, fundingTxId, acknowledged };
+        });
+    };
+    methods.set('totem_omniaSubmitOpenChannel', submitOpenChannel);
+    methods.set('omnia/submitOpenChannel', submitOpenChannel);
+    const prepareSplice = (type) => async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.preparedSplice || !context.spliceAcceptances) {
+            throw new Error('Splice manager is not configured');
+        }
+        if (!context.swarm)
+            throw new Error('Splice preparation requires swarm connectivity');
+        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;
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPartyId || !localPkd)
+            throw new Error('Local participant is not configured');
+        if (channel.status !== 'active')
+            throw new Error(`Channel ${channelId} is not active (${channel.status})`);
+        const pending = channel.pendingHTLCs.filter((h) => h.status === 'pending');
+        if (pending.length > 0)
+            throw new Error(`Cannot splice with ${pending.length} pending HTLC(s)`);
+        const remote = channel.parties.find((party) => party.partyId !== localPartyId);
+        if (!remote)
+            throw new Error('Channel counterparty not found');
+        const nextSequence = channel.currentSequence + 1;
+        const quiesceUnsigned = (0, omnia_1.buildStateUpdate)(channel, { newSequence: nextSequence, newBalances: { ...channel.balances } }, { publicKeyDigest: localPkd });
+        const quiescedChannel = {
+            ...channel,
+            currentSequence: nextSequence,
+            balances: { ...channel.balances },
+            pendingHTLCs: [],
+            latestState: null,
+            status: 'quiesced',
+            quiesceSignedState: quiesceUnsigned.unsignedClosePackage,
+            updatedAt: Date.now(),
+        };
+        const parsedBalances = params.newBalances && typeof params.newBalances === 'object'
+            ? Object.fromEntries(Object.entries(params.newBalances).map(([partyId, value]) => [partyId, BigInt(String(value))]))
+            : undefined;
+        const unsigned = type === 'in'
+            ? (0, omnia_splice_1.buildSpliceInProposal)(quiescedChannel, requiredString(params, 'additionalCoinId'), requiredBigInt(params, 'additionalAmount'), localPkd, parsedBalances)
+            : (0, omnia_splice_1.buildSpliceOutProposal)(quiescedChannel, requiredBigInt(params, 'withdrawAmount'), requiredString(params, 'withdrawAddress'), localPkd, parsedBalances);
+        return withOperation(context, params, async () => {
+            const placeholder = {
+                spliceId: unsigned.spliceId,
+                channelId: unsigned.channelId,
+                params: unsigned.params,
+                spliceTxHex: unsigned.spliceTxHex,
+                spliceTxDraft: unsigned.spliceTxDraft,
+                proposerPublicKeyDigest: localPkd,
+                proposerSignature: new Uint8Array(0),
+                proposerReservationId: '',
+                proposerSigningIndices: { addressIndex: 0, l1: 0, l2: 0 },
+                proposedAt: Date.now(),
+            };
+            const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, channelId, remote.transportPubkey);
+            const reply = await requestPeerReply(peer, { type: 'SPLICE_PROPOSAL', channelId, nonce: Date.now(), payload: { proposal: placeholder } }, 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(unsigned.spliceId, acceptance);
+            const preparedOperationId = operationId(params);
+            const expiresAt = Date.now() + 300_000;
+            const base = {
+                domain: 'splice',
+                signers: [localPkd],
+                custody: (0, omnia_1.makeSelfCustody)(),
+                expiresAt,
+            };
+            const quiesceIntent = {
+                ...base,
+                domain: 'channel',
+                requestId: `${preparedOperationId}:quiesce:intent`,
+                kind: 'intent',
+                digest: quiesceUnsigned.updateDigest,
+                context: { summary: `Authorize quiesce before ${type === 'in' ? 'splice-in' : 'splice-out'}` },
+            };
+            const quiesceUpdate = {
+                ...base,
+                domain: 'channel',
+                requestId: `${preparedOperationId}:quiesce:update`,
+                kind: 'chain',
+                digest: quiesceUnsigned.updateDigest,
+                context: { summary: 'Sign the quiesce channel update' },
+            };
+            const quiesceSettlement = {
+                ...base,
+                domain: 'channel',
+                requestId: `${preparedOperationId}:quiesce:settlement`,
+                kind: 'chain',
+                digest: quiesceUnsigned.settlementDigest,
+                context: { summary: 'Sign the quiesce settlement package' },
+            };
+            const intent = {
+                ...base,
+                requestId: `${preparedOperationId}:intent`,
+                kind: 'intent',
+                digest: unsigned.digest,
+                context: {
+                    summary: `Authorize ${type === 'in' ? 'splice-in' : 'splice-out'} on ${channelId}`,
+                    amount: unsigned.params.newTotalValue.toString(),
+                },
+            };
+            const splice = {
+                ...base,
+                requestId: `${preparedOperationId}:splice`,
+                kind: 'chain',
+                digest: unsigned.digest,
+                context: { summary: 'Sign the splice transaction' },
+            };
+            for (const [key, entry] of context.preparedSplice) {
+                if (entry.expiresAt <= Date.now())
+                    context.preparedSplice.delete(key);
+            }
+            context.preparedSplice.set(preparedOperationId, {
+                channelId,
+                quiescedChannel,
+                quiesce: {
+                    unsigned: quiesceUnsigned,
+                    intent: quiesceIntent,
+                    update: quiesceUpdate,
+                    settlement: quiesceSettlement,
+                },
+                unsigned,
+                acceptance,
+                intent,
+                splice,
+                expiresAt,
+            });
+            return {
+                success: true,
+                status: 'signature-required',
+                operationId: preparedOperationId,
+                channelId,
+                spliceId: unsigned.spliceId,
+                spliceType: type,
+                requests: {
+                    quiesce: { intent: quiesceIntent, update: quiesceUpdate, settlement: quiesceSettlement },
+                    splice: { intent, chain: splice },
+                },
+                expiresAt,
+            };
+        });
+    };
+    methods.set('totem_omniaPrepareSpliceIn', prepareSplice('in'));
+    methods.set('omnia/prepareSpliceIn', prepareSplice('in'));
+    methods.set('totem_omniaPrepareSpliceOut', prepareSplice('out'));
+    methods.set('omnia/prepareSpliceOut', prepareSplice('out'));
+    const submitSplice = async (raw) => {
+        const params = paramsObject(raw);
+        const preparedOperationId = requiredString(params, 'preparedOperationId');
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPkd)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedSplice)
+            throw new Error('Prepared-splice store is not configured');
+        return withOperation(context, params, async () => {
+            const entry = context.preparedSplice.get(preparedOperationId);
+            if (!entry)
+                throw new Error(`Prepared splice ${preparedOperationId} not found`);
+            if (entry.expiresAt <= Date.now()) {
+                context.preparedSplice.delete(preparedOperationId);
+                throw new Error(`Prepared splice ${preparedOperationId} has expired`);
+            }
+            const quiesceIntentSignature = hexBytes(params.quiesceIntentSignature, 'quiesceIntentSignature');
+            const quiesceUpdateSignature = hexBytes(params.quiesceUpdateSignature, 'quiesceUpdateSignature');
+            const quiesceSettlementSignature = hexBytes(params.quiesceSettlementSignature, 'quiesceSettlementSignature');
+            const spliceIntentSignature = hexBytes(params.spliceIntentSignature, 'spliceIntentSignature');
+            const spliceSignature = hexBytes(params.spliceSignature, 'spliceSignature');
+            const updateIndices = signingIndicesParam(params.quiesceUpdateIndices);
+            const settlementIndices = signingIndicesParam(params.quiesceSettlementIndices);
+            const spliceIndices = params.spliceIndices
+                ? signingIndicesParam(params.spliceIndices)
+                : { addressIndex: 0, l1: 0, l2: 0 };
+            if (!(0, omnia_1.verifyChannelSignature)(quiesceIntentSignature, (0, omnia_1.signRequestPayload)(entry.quiesce.intent), localPkd)) {
+                throw new Error('quiesce intent signature does not verify');
+            }
+            if (!(0, omnia_1.verifyChannelSignature)(quiesceUpdateSignature, entry.quiesce.unsigned.updateDigest, localPkd)) {
+                throw new Error('quiesce update signature does not verify');
+            }
+            if (!(0, omnia_1.verifyChannelSignature)(quiesceSettlementSignature, entry.quiesce.unsigned.settlementDigest, localPkd)) {
+                throw new Error('quiesce settlement signature does not verify');
+            }
+            if (!(0, omnia_1.verifyChannelSignature)(spliceIntentSignature, (0, omnia_1.signRequestPayload)(entry.intent), localPkd)) {
+                throw new Error('splice intent signature does not verify');
+            }
+            if (!(0, omnia_1.verifyChannelSignature)(spliceSignature, entry.unsigned.digest, localPkd)) {
+                throw new Error('splice signature does not verify');
+            }
+            if (!context.chainProvider?.broadcastTxPoW) {
+                throw new Error('Splice requires a chain provider with broadcastTxPoW');
+            }
+            const quiesceState = (0, omnia_1.finalizeStateUpdateWithIndices)(entry.quiesce.unsigned, quiesceUpdateSignature, updateIndices, quiesceSettlementSignature, settlementIndices);
+            const quiescedChannel = {
+                ...entry.quiescedChannel,
+                balances: quiesceState.balances,
+                currentSequence: quiesceState.sequence,
+                pendingHTLCs: [],
+                latestState: quiesceState,
+                quiesceSignedState: quiesceState,
+                status: 'quiesced',
+                updatedAt: Date.now(),
+            };
+            const { digest: _digest, ...unsignedBase } = entry.unsigned;
+            const proposal = {
+                ...unsignedBase,
+                proposerSignature: spliceSignature,
+                proposerReservationId: '',
+                proposerSigningIndices: spliceIndices,
+                proposedAt: Date.now(),
+            };
+            const spliced = await (0, omnia_splice_1.finalizeSplice)(quiescedChannel, proposal, entry.acceptance, {
+                broadcast: (txHex) => context.chainProvider.broadcastTxPoW(txHex),
+            });
+            context.channels.set(entry.channelId, spliced);
+            if (context.swarm) {
+                const remote = spliced.parties.find((party) => party.partyId !== context.localParticipant.partyId);
+                if (remote) {
+                    const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, entry.channelId, remote.transportPubkey);
+                    await peer.sendMessage({
+                        type: 'SPLICE_FINALIZED',
+                        channelId: entry.channelId,
+                        nonce: Date.now(),
+                        payload: {
+                            channel: spliced,
+                            txId: spliced.spliceFundingTxId,
+                            spliceId: entry.unsigned.spliceId,
+                        },
+                    });
+                }
+            }
+            context.preparedSplice.delete(preparedOperationId);
+            return {
+                success: true,
+                channelId: entry.channelId,
+                spliceId: entry.unsigned.spliceId,
+                spliceType: spliced.spliceType,
+                totalValue: spliced.totalValue.toString(),
+                balances: Object.fromEntries(Object.entries(spliced.balances).map(([partyId, amount]) => [partyId, amount.toString()])),
+                fundingCoinId: spliced.spliceFundingCoinId,
+            };
+        });
+    };
+    methods.set('totem_omniaSubmitSplice', submitSplice);
+    methods.set('omnia/submitSplice', submitSplice);
+    const prepareFactory = async (raw) => {
+        const params = paramsObject(raw);
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPkd)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedFactory)
+            throw new Error('Prepared-factory store is not configured');
+        const participantsRaw = params.participants;
+        if (!Array.isArray(participantsRaw) || participantsRaw.length < 2) {
+            throw new Error('participants must contain at least two factory participants');
+        }
+        const participants = participantsRaw.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,
+                transportPubkey: typeof item.transportPubkey === 'string' ? item.transportPubkey : undefined,
+            };
+        });
+        const toBytes = (value) => typeof value === 'string' ? Buffer.from(value.replace(/^0x/i, ''), 'hex') : undefined;
+        const fundingMaterials = Array.isArray(params.funding)
+            ? params.funding.map((value) => {
+                if (!value || typeof value !== 'object')
+                    throw new Error('Invalid factory funding material');
+                const item = value;
+                const coinProof = toBytes(item.coinProof);
+                if (!coinProof)
+                    throw new Error('factory funding material requires coinProof');
+                return {
+                    partyId: requiredString(item, 'partyId'),
+                    coinProof,
+                    ...(typeof item.coinAddress === 'string' ? { coinAddress: item.coinAddress } : {}),
+                    ...(typeof item.script === 'string' ? { script: item.script } : {}),
+                    ...(toBytes(item.scriptProof) ? { scriptProof: toBytes(item.scriptProof) } : {}),
+                };
+            })
+            : undefined;
+        const tokenId = typeof params.tokenId === 'string' ? params.tokenId : '0x00';
+        const tokenScale = typeof params.tokenScale === 'number' ? params.tokenScale : 0;
+        const remote = participants.find((participant) => participant.publicKeyDigest !== localPkd);
+        return withOperation(context, params, async () => {
+            const plan = await (0, omnia_factory_1.buildFactoryOpening)(participants, tokenId, tokenScale, context.chainProvider, fundingMaterials);
+            let remoteFundingSignature;
+            if (plan.onChain && context.swarm && remote) {
+                const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, plan.factory.factoryId, remote.transportPubkey);
+                const reply = await requestPeerReply(peer, {
+                    type: 'FACTORY_FUNDING_REQUEST',
+                    channelId: plan.factory.factoryId,
+                    nonce: Date.now(),
+                    payload: { digest: '0x' + Buffer.from(plan.fundingDigest).toString('hex') },
+                }, plan.factory.factoryId, 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'})`);
+                remoteFundingSignature = Uint8Array.from(Buffer.from(signature.replace(/^0x/i, ''), 'hex'));
+            }
+            const preparedOperationId = operationId(params);
+            const expiresAt = Date.now() + 300_000;
+            const commitment = Buffer.from(plan.factory.pendingCommitment, 'hex');
+            const base = {
+                domain: 'factory',
+                signers: [localPkd],
+                custody: (0, omnia_1.makeSelfCustody)(),
+                expiresAt,
+            };
+            const intent = {
+                ...base,
+                requestId: `${preparedOperationId}:intent`,
+                kind: 'intent',
+                digest: commitment,
+                context: {
+                    summary: `Authorize factory opening (${plan.factory.totalValue} units)`,
+                    amount: plan.factory.totalValue.toString(),
+                    asset: plan.factory.tokenId,
+                },
+            };
+            const commitmentRequest = {
+                ...base,
+                requestId: `${preparedOperationId}:commitment`,
+                kind: 'chain',
+                digest: commitment,
+                context: { summary: 'Sign the factory funding/opening commitment' },
+            };
+            for (const [key, entry] of context.preparedFactory) {
+                if (entry.expiresAt <= Date.now())
+                    context.preparedFactory.delete(key);
+            }
+            context.preparedFactory.set(preparedOperationId, {
+                plan,
+                remotePartyId: remote?.partyId,
+                remoteFundingSignature,
+                intent,
+                commitment: commitmentRequest,
+                expiresAt,
+            });
+            return {
+                success: true,
+                status: 'signature-required',
+                operationId: preparedOperationId,
+                factoryId: plan.factory.factoryId,
+                onChain: plan.onChain,
+                fundingCoinId: plan.fundingCoinId,
+                totalValue: plan.factory.totalValue.toString(),
+                requests: { intent, commitment: commitmentRequest },
+                expiresAt,
+            };
+        });
+    };
+    methods.set('totem_omniaPrepareFactory', prepareFactory);
+    methods.set('omnia/prepareFactory', prepareFactory);
+    const submitFactory = async (raw) => {
+        const params = paramsObject(raw);
+        const preparedOperationId = requiredString(params, 'preparedOperationId');
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        const localPartyId = context.localParticipant?.partyId;
+        if (!localPkd || !localPartyId)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedFactory)
+            throw new Error('Prepared-factory store is not configured');
+        return withOperation(context, params, async () => {
+            const entry = context.preparedFactory.get(preparedOperationId);
+            if (!entry)
+                throw new Error(`Prepared factory ${preparedOperationId} not found`);
+            if (entry.expiresAt <= Date.now()) {
+                context.preparedFactory.delete(preparedOperationId);
+                throw new Error(`Prepared factory ${preparedOperationId} has expired`);
+            }
+            const intentSignature = hexBytes(params.intentSignature, 'intentSignature');
+            const commitmentSignature = hexBytes(params.commitmentSignature, 'commitmentSignature');
+            const commitment = Buffer.from(entry.plan.factory.pendingCommitment, 'hex');
+            if (!(0, omnia_1.verifyChannelSignature)(intentSignature, (0, omnia_1.signRequestPayload)(entry.intent), localPkd)) {
+                throw new Error('intent signature does not verify');
+            }
+            if (!(0, omnia_1.verifyChannelSignature)(commitmentSignature, commitment, localPkd)) {
+                throw new Error('factory commitment signature does not verify');
+            }
+            if (!context.chainProvider && entry.plan.onChain)
+                throw new Error('Factory funding requires a chain provider');
+            const fundingSignatures = { [localPartyId]: commitmentSignature };
+            if (entry.remotePartyId && entry.remoteFundingSignature) {
+                fundingSignatures[entry.remotePartyId] = entry.remoteFundingSignature;
+            }
+            let factory = await (0, omnia_factory_1.finalizeFactoryOpening)(entry.plan, {
+                fundingSignatures: entry.plan.onChain ? fundingSignatures : undefined,
+                openingSignatures: { [localPartyId]: commitmentSignature },
+            }, context.chainProvider);
+            context.factories?.set(factory.factoryId, factory);
+            if (context.swarm && entry.remotePartyId) {
+                const remote = factory.participants.find((participant) => participant.partyId === entry.remotePartyId);
+                if (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);
+                }
+            }
+            context.preparedFactory.delete(preparedOperationId);
+            return { success: true, factoryId: factory.factoryId, status: factory.status, fundingTxId: factory.fundingTxId };
+        });
+    };
+    methods.set('totem_omniaSubmitFactory', submitFactory);
+    methods.set('omnia/submitFactory', submitFactory);
+    const createVtxoPoolMethod = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.vtxoPools)
+            throw new Error('VTXO stores are not configured');
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        const operator = typeof params.operator === 'string' ? params.operator : localPkd;
+        if (!operator)
+            throw new Error('VTXO pool operator is required');
+        const pool = (0, omnia_vtxo_1.createPool)({
+            operator,
+            tokenId: typeof params.tokenId === 'string' ? params.tokenId : '0x00',
+            totalCapacity: requiredBigInt(params, 'totalCapacity'),
+            nonce: requiredString(params, 'nonce'),
+            ...(params.policy && typeof params.policy === 'object' ? { policy: params.policy } : {}),
+        }, typeof params.now === 'number' ? params.now : Date.now());
+        context.vtxoPools.set(pool.poolId, pool);
+        return { success: true, pool: jsonSafe(pool) };
+    };
+    methods.set('totem_omniaCreateVtxoPool', createVtxoPoolMethod);
+    methods.set('omnia/createVtxoPool', createVtxoPoolMethod);
+    const mintVtxoMethod = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.vtxoPools || !context.vtxos || !context.vtxoReceipts)
+            throw new Error('VTXO stores are not configured');
+        const pool = context.vtxoPools.get(requiredString(params, 'poolId'));
+        if (!pool)
+            throw new Error(`VTXO pool ${String(params.poolId)} not found`);
+        const minted = (0, omnia_vtxo_1.mintVtxo)(pool, {
+            owner: requiredString(params, 'owner'),
+            amount: requiredBigInt(params, 'amount'),
+            nonce: requiredString(params, 'nonce'),
+            expiresAt: typeof params.expiresAt === 'number' ? params.expiresAt : undefined,
+            fundingProof: params.fundingProof,
+        }, typeof params.now === 'number' ? params.now : undefined);
+        context.vtxoPools.set(pool.poolId, minted.pool);
+        context.vtxos.set(minted.vtxo.vtxoId, minted.vtxo);
+        context.vtxoReceipts.set(minted.receipt.receiptId, minted.receipt);
+        return { success: true, pool: jsonSafe(minted.pool), vtxo: jsonSafe(minted.vtxo), receipt: jsonSafe(minted.receipt) };
+    };
+    methods.set('totem_omniaMintVtxo', mintVtxoMethod);
+    methods.set('omnia/mintVtxo', mintVtxoMethod);
+    const transferVtxoMethod = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.vtxos || !context.vtxoReceipts)
+            throw new Error('VTXO stores are not configured');
+        const vtxo = context.vtxos.get(requiredString(params, 'vtxoId'));
+        if (!vtxo)
+            throw new Error(`VTXO ${String(params.vtxoId)} not found`);
+        const result = (0, omnia_vtxo_1.transferVtxo)(vtxo, {
+            recipient: requiredString(params, 'recipient'),
+            amount: requiredBigInt(params, 'amount'),
+            nonce: requiredString(params, 'nonce'),
+            changeNonce: typeof params.changeNonce === 'string' ? params.changeNonce : undefined,
+        }, typeof params.now === 'number' ? params.now : undefined);
+        context.vtxos.set(result.input.vtxoId, result.input);
+        context.vtxos.set(result.output.vtxoId, result.output);
+        if (result.change)
+            context.vtxos.set(result.change.vtxoId, result.change);
+        context.vtxoReceipts.set(result.receipt.receiptId, result.receipt);
+        return {
+            success: true,
+            input: jsonSafe(result.input),
+            output: jsonSafe(result.output),
+            change: result.change ? jsonSafe(result.change) : undefined,
+            receipt: jsonSafe(result.receipt),
+        };
+    };
+    methods.set('totem_omniaTransferVtxo', transferVtxoMethod);
+    methods.set('omnia/transferVtxo', transferVtxoMethod);
+    const refreshVtxoMethod = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.vtxos || !context.vtxoReceipts)
+            throw new Error('VTXO stores are not configured');
+        const vtxo = context.vtxos.get(requiredString(params, 'vtxoId'));
+        if (!vtxo)
+            throw new Error(`VTXO ${String(params.vtxoId)} not found`);
+        const result = (0, omnia_vtxo_1.refreshVtxo)(vtxo, {
+            newEpoch: Number(params.newEpoch),
+            nonce: requiredString(params, 'nonce'),
+        }, typeof params.now === 'number' ? params.now : undefined);
+        context.vtxos.set(result.old.vtxoId, result.old);
+        context.vtxos.set(result.refreshed.vtxoId, result.refreshed);
+        if (context.vtxoPools) {
+            const pool = context.vtxoPools.get(vtxo.poolId);
+            if (pool)
+                context.vtxoPools.set(pool.poolId, { ...pool, epoch: result.refreshed.epoch });
+        }
+        context.vtxoReceipts.set(result.receipt.receiptId, result.receipt);
+        return { success: true, old: jsonSafe(result.old), refreshed: jsonSafe(result.refreshed), receipt: jsonSafe(result.receipt) };
+    };
+    methods.set('totem_omniaRefreshVtxo', refreshVtxoMethod);
+    methods.set('omnia/refreshVtxo', refreshVtxoMethod);
+    const initiateVtxoExitMethod = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.vtxos || !context.vtxoReceipts)
+            throw new Error('VTXO stores are not configured');
+        const vtxo = context.vtxos.get(requiredString(params, 'vtxoId'));
+        if (!vtxo)
+            throw new Error(`VTXO ${String(params.vtxoId)} not found`);
+        const now = typeof params.now === 'number' ? params.now : undefined;
+        const draft = (0, omnia_vtxo_1.createExitDraft)(vtxo, now);
+        const exiting = (0, omnia_vtxo_1.markExiting)(vtxo, now);
+        context.vtxos.set(exiting.vtxoId, exiting);
+        context.vtxoReceipts.set(draft.receipt.receiptId, draft.receipt);
+        return { success: true, vtxo: jsonSafe(exiting), draft: jsonSafe(draft.draft), receipt: jsonSafe(draft.receipt) };
+    };
+    methods.set('totem_omniaInitiateVtxoExit', initiateVtxoExitMethod);
+    methods.set('omnia/initiateVtxoExit', initiateVtxoExitMethod);
+    const completeVtxoExitMethod = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.vtxos)
+            throw new Error('VTXO stores are not configured');
+        const vtxo = context.vtxos.get(requiredString(params, 'vtxoId'));
+        if (!vtxo)
+            throw new Error(`VTXO ${String(params.vtxoId)} not found`);
+        const exited = (0, omnia_vtxo_1.markExited)(vtxo, {
+            txpowId: typeof params.txpowId === 'string' ? params.txpowId : undefined,
+            now: typeof params.now === 'number' ? params.now : undefined,
+        });
+        context.vtxos.set(exited.vtxoId, exited);
+        return { success: true, vtxo: jsonSafe(exited) };
+    };
+    methods.set('totem_omniaCompleteVtxoExit', completeVtxoExitMethod);
+    methods.set('omnia/completeVtxoExit', completeVtxoExitMethod);
+    const prepareVtxoReceipt = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.vtxoReceipts || !context.vtxos || !context.preparedVtxoReceipts) {
+            throw new Error('VTXO stores are not configured');
+        }
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPkd)
+            throw new Error('Local participant is not configured');
+        const receipt = context.vtxoReceipts.get(requiredString(params, 'receiptId'));
+        if (!receipt)
+            throw new Error(`VTXO receipt ${String(params.receiptId)} not found`);
+        const outputs = receipt.outputIds.map((id) => {
+            const vtxo = context.vtxos.get(id);
+            if (!vtxo)
+                throw new Error(`VTXO ${id} referenced by receipt is not stored`);
+            return vtxo;
+        });
+        const root = typeof params.root === 'string' ? params.root : outputs[0]?.proof.root;
+        const epoch = typeof params.epoch === 'number' ? params.epoch : receipt.epoch;
+        if (!root)
+            throw new Error('VTXO receipt root is required');
+        const payload = (0, omnia_vtxo_1.buildVtxoReceiptPayload)(receipt, {
+            outputs,
+            root,
+            epoch,
+            previousEpoch: typeof params.previousEpoch === 'number' ? params.previousEpoch : undefined,
+            inputsAmount: params.inputsAmount !== undefined ? BigInt(String(params.inputsAmount)) : undefined,
+        });
+        const request = {
+            requestId: `vtxo-receipt-${receipt.receiptId}`,
+            kind: 'chain',
+            domain: 'vtxo',
+            digest: payload,
+            context: { summary: `Co-sign VTXO ${receipt.op} receipt` },
+            signers: [localPkd],
+            custody: (0, omnia_1.makeSelfCustody)(),
+            expiresAt: Date.now() + 120_000,
+        };
+        const expiresAt = Date.now() + 120_000;
+        context.preparedVtxoReceipts.set(receipt.receiptId, { receipt, payload, request, expiresAt });
+        return { success: true, status: 'signature-required', receiptId: receipt.receiptId, requests: { receipt: request }, expiresAt };
+    };
+    methods.set('totem_omniaPrepareVtxoReceipt', prepareVtxoReceipt);
+    methods.set('omnia/prepareVtxoReceipt', prepareVtxoReceipt);
+    const submitVtxoReceipt = async (raw) => {
+        const params = paramsObject(raw);
+        const receiptId = requiredString(params, 'receiptId');
+        const localPkd = context.localParticipant?.publicKeyDigest;
+        if (!localPkd)
+            throw new Error('Local participant is not configured');
+        if (!context.preparedVtxoReceipts || !context.vtxoReceipts)
+            throw new Error('VTXO stores are not configured');
+        const entry = context.preparedVtxoReceipts.get(receiptId);
+        if (!entry)
+            throw new Error(`Prepared VTXO receipt ${receiptId} not found`);
+        if (entry.expiresAt <= Date.now()) {
+            context.preparedVtxoReceipts.delete(receiptId);
+            throw new Error(`Prepared VTXO receipt ${receiptId} has expired`);
+        }
+        const signature = hexBytes(params.signature, 'signature');
+        if (!(0, omnia_1.verifyChannelSignature)(signature, entry.payload, localPkd)) {
+            throw new Error('VTXO receipt signature does not verify');
+        }
+        const signed = { ...entry.receipt, signature: '0x' + Buffer.from(signature).toString('hex') };
+        context.vtxoReceipts.set(receiptId, signed);
+        context.preparedVtxoReceipts.delete(receiptId);
+        return { success: true, receipt: jsonSafe(signed) };
+    };
+    methods.set('totem_omniaSubmitVtxoReceipt', submitVtxoReceipt);
+    methods.set('omnia/submitVtxoReceipt', submitVtxoReceipt);
+    const createLiquidityPool = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.pools)
+            throw new Error('Pool stores are not configured');
+        const created = (0, omnia_pool_1.createOmniaPool)({
+            poolId: requiredString(params, 'poolId'),
+            operatorAddress: requiredString(params, 'operatorAddress'),
+            tokenId: typeof params.tokenId === 'string' ? params.tokenId : '0x00',
+            purpose: requiredString(params, 'purpose'),
+            poolType: requiredString(params, 'poolType'),
+            capacity: String(requiredBigInt(params, 'capacity')),
+            feePolicy: params.feePolicy,
+            riskPolicy: params.riskPolicy,
+            lockTerms: params.lockTerms,
+            operatorBond: params.operatorBond,
+            metadata: params.metadata,
+        }, (0, liquidity_bond_1.createEmptyLiquidityBondRegistryState)());
+        context.pools.set(created.manifest.poolId, { manifest: created.manifest, registry: created.registry });
+        return { success: true, pool: jsonSafe(created.manifest), registry: jsonSafe(created.registry) };
+    };
+    methods.set('totem_omniaCreateLiquidityPool', createLiquidityPool);
+    methods.set('omnia/createLiquidityPool', createLiquidityPool);
+    const depositToLiquidityPool = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.pools || !context.poolPositions)
+            throw new Error('Pool stores are not configured');
+        const poolId = requiredString(params, 'poolId');
+        const stored = context.pools.get(poolId);
+        if (!stored)
+            throw new Error(`Pool ${poolId} not found`);
+        const verifier = {
+            verifyDeposit: async (request) => {
+                if (!context.chainProvider)
+                    return { valid: false, reason: 'no chain provider' };
+                const coin = await context.chainProvider.getCoin(request.coinId);
+                if (!coin)
+                    return { valid: false, reason: 'coin not found' };
+                if (coin.spent)
+                    return { valid: false, reason: 'coin is spent' };
+                if (request.tokenId && coin.tokenid !== request.tokenId)
+                    return { valid: false, reason: 'token mismatch' };
+                if (request.claimedAmount && BigInt(coin.amount) < BigInt(request.claimedAmount)) {
+                    return { valid: false, reason: 'insufficient amount' };
+                }
+                return { valid: true };
+            },
+        };
+        const deposited = await (0, omnia_pool_1.depositToPool)({
+            pool: stored.manifest,
+            lpAddress: requiredString(params, 'lpAddress'),
+            amount: String(requiredBigInt(params, 'amount')),
+            purpose: requiredString(params, 'purpose'),
+            underlyingUtxoRef: typeof params.underlyingUtxoRef === 'string' ? params.underlyingUtxoRef : undefined,
+            underlyingRefs: params.underlyingRefs,
+            metadata: params.metadata,
+            chainProvider: verifier,
+        }, stored.registry);
+        context.pools.set(poolId, { manifest: deposited.pool, registry: deposited.state });
+        context.poolPositions.set(deposited.position.positionId, { position: deposited.position, registry: deposited.state });
+        return {
+            success: true,
+            poolId,
+            position: jsonSafe(deposited.position),
+            receipt: jsonSafe(deposited.receipt),
+            registry: jsonSafe(deposited.state),
+        };
+    };
+    methods.set('totem_omniaDepositToPool', depositToLiquidityPool);
+    methods.set('omnia/depositToPool', depositToLiquidityPool);
+    const allocatePoolCapital = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.poolPositions)
+            throw new Error('Pool stores are not configured');
+        const positionId = requiredString(params, 'positionId');
+        const stored = context.poolPositions.get(positionId);
+        if (!stored)
+            throw new Error(`Pool position ${positionId} not found`);
+        const allocated = await (0, omnia_pool_1.allocatePositionCapital)({
+            position: stored.position,
+            amount: String(requiredBigInt(params, 'amount')),
+            allocationType: requiredString(params, 'allocationType'),
+            purpose: requiredString(params, 'purpose'),
+            target: params.target,
+            metadata: params.metadata,
+        }, stored.registry);
+        context.poolPositions.set(positionId, { ...stored, position: allocated.position, registry: allocated.registry, allocation: allocated.allocation });
+        return {
+            success: true,
+            position: jsonSafe(allocated.position),
+            allocation: jsonSafe(allocated.allocation),
+            registry: jsonSafe(allocated.registry),
+        };
+    };
+    methods.set('totem_omniaAllocatePoolCapital', allocatePoolCapital);
+    methods.set('omnia/allocatePoolCapital', allocatePoolCapital);
+    const releasePoolAllocation = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.poolPositions)
+            throw new Error('Pool stores are not configured');
+        const positionId = requiredString(params, 'positionId');
+        const stored = context.poolPositions.get(positionId);
+        if (!stored)
+            throw new Error(`Pool position ${positionId} not found`);
+        if (!stored.allocation)
+            throw new Error(`Pool position ${positionId} has no allocation`);
+        const released = (0, omnia_pool_1.releaseAllocation)({ allocation: stored.allocation, position: stored.position }, stored.registry);
+        context.poolPositions.set(positionId, { ...stored, position: released.position, registry: released.registry, allocation: undefined });
+        return { success: true, position: jsonSafe(released.position), registry: jsonSafe(released.registry) };
+    };
+    methods.set('totem_omniaReleasePoolAllocation', releasePoolAllocation);
+    methods.set('omnia/releasePoolAllocation', releasePoolAllocation);
+    const withdrawPoolLiquidity = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.pools || !context.poolPositions)
+            throw new Error('Pool stores are not configured');
+        const positionId = requiredString(params, 'positionId');
+        const stored = context.poolPositions.get(positionId);
+        if (!stored)
+            throw new Error(`Pool position ${positionId} not found`);
+        const pool = context.pools.get(stored.position.poolId);
+        if (!pool)
+            throw new Error(`Pool ${stored.position.poolId} not found`);
+        const withdrawn = (0, omnia_pool_1.withdrawLiquidity)(pool.manifest, stored.position, {
+            positionId,
+            amount: String(requiredBigInt(params, 'amount')),
+            recipientAddress: requiredString(params, 'recipientAddress'),
+            reason: typeof params.reason === 'string' ? params.reason : undefined,
+        }, stored.registry);
+        context.poolPositions.set(positionId, { ...stored, position: withdrawn.position, registry: withdrawn.state, intent: withdrawn.intent });
+        return { success: true, intent: jsonSafe(withdrawn.intent), position: jsonSafe(withdrawn.position), registry: jsonSafe(withdrawn.state) };
+    };
+    methods.set('totem_omniaWithdrawPool', withdrawPoolLiquidity);
+    methods.set('omnia/withdrawPool', withdrawPoolLiquidity);
+    const approvePoolWithdrawal = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.poolPositions)
+            throw new Error('Pool stores are not configured');
+        const positionId = requiredString(params, 'positionId');
+        const stored = context.poolPositions.get(positionId);
+        if (!stored)
+            throw new Error(`Pool position ${positionId} not found`);
+        if (!stored.intent)
+            throw new Error(`Pool position ${positionId} has no withdrawal intent`);
+        const approved = (0, omnia_pool_1.approveWithdrawal)(stored.intent, stored.position, stored.registry);
+        context.poolPositions.set(positionId, { ...stored, registry: approved.registry, intent: approved.intent });
+        return { success: true, intent: jsonSafe(approved.intent), registry: jsonSafe(approved.registry) };
+    };
+    methods.set('totem_omniaApprovePoolWithdrawal', approvePoolWithdrawal);
+    methods.set('omnia/approvePoolWithdrawal', approvePoolWithdrawal);
+    const executePoolPayoutMethod = async (raw) => {
+        const params = paramsObject(raw);
+        if (!context.pools || !context.poolPositions)
+            throw new Error('Pool stores are not configured');
+        const positionId = requiredString(params, 'positionId');
+        const stored = context.poolPositions.get(positionId);
+        if (!stored)
+            throw new Error(`Pool position ${positionId} not found`);
+        if (!stored.intent)
+            throw new Error(`Pool position ${positionId} has no withdrawal intent`);
+        const pool = context.pools.get(stored.position.poolId);
+        if (!pool)
+            throw new Error(`Pool ${stored.position.poolId} not found`);
+        const signIndices = params.signIndices ? signingIndicesParam(params.signIndices) : undefined;
+        if (signIndices && !context.signer)
+            throw new Error('Pool payout signing requires a signer');
+        const paid = await (0, omnia_pool_1.executePoolPayout)({
+            pool: pool.manifest,
+            position: stored.position,
+            intent: stored.intent,
+            recipientAddress: requiredString(params, 'recipientAddress'),
+            settlement: params.settlement,
+            ...(signIndices && context.signer
+                ? { rooting: { signer: context.signer, signIndices } }
+                : {}),
+        }, stored.registry);
+        context.poolPositions.set(positionId, {
+            ...stored,
+            position: paid.position,
+            registry: paid.registry,
+            intent: paid.intent,
+        });
+        return {
+            success: true,
+            intent: jsonSafe(paid.intent),
+            position: jsonSafe(paid.position),
+            registry: jsonSafe(paid.registry),
+            signedTransition: paid.signedTransition ? jsonSafe(paid.signedTransition) : undefined,
+        };
+    };
+    methods.set('totem_omniaExecutePoolPayout', executePoolPayoutMethod);
+    methods.set('omnia/executePoolPayout', executePoolPayoutMethod);
+}
 function createHostMethods(context) {
     const methods = new Map();
     const register = (name, handler, alias) => {
         methods.set(name, handler);
         methods.set(alias, handler);
     };
+    const observeMethods = (map) => {
+        const emitter = context.observe;
+        if (!emitter)
+            return map;
+        const observed = new Map();
+        const isQuiet = (name) => name.startsWith('totem_omniaGet') || name === 'totem_omniaWhoami' ||
+            name === 'totem_omniaGetManifest';
+        for (const [name, handler] of map) {
+            observed.set(name, async (params) => {
+                if (isQuiet(name))
+                    return handler(params);
+                const startedAt = Date.now();
+                const raw = paramsObject(params);
+                const opId = typeof raw.operationId === 'string' ? raw.operationId : undefined;
+                void emitter.emit({
+                    domain: 'command', kind: 'command.invoked', phase: 'observed',
+                    entity: { type: 'command', id: name },
+                    ...(opId ? { operationId: opId } : {}),
+                    data: { method: name, params },
+                });
+                try {
+                    const result = await handler(params);
+                    void emitter.emit({
+                        domain: 'command', kind: 'command.completed', phase: 'committed',
+                        entity: { type: 'command', id: name },
+                        ...(opId ? { operationId: opId } : {}),
+                        data: { method: name, durationMs: Date.now() - startedAt, result },
+                    });
+                    return result;
+                }
+                catch (error) {
+                    void emitter.emit({
+                        domain: 'command', kind: 'command.failed', phase: 'failed',
+                        entity: { type: 'command', id: name },
+                        ...(opId ? { operationId: opId } : {}),
+                        data: { method: name, durationMs: Date.now() - startedAt, error: error instanceof Error ? error.message : String(error) },
+                    });
+                    throw error;
+                }
+            });
+        }
+        return observed;
+    };
     const getChannels = (raw) => {
         const params = paramsObject(raw);
         const tokenId = typeof params.tokenId === 'string' ? params.tokenId : undefined;
@@ -264,12 +1673,23 @@ function createHostMethods(context) {
         return channelStateView(channel);
     };
     register('totem_omniaGetChannelState', getChannelState, 'omnia/getChannelState');
+    const normalizeRouteNode = (value) => {
+        const lower = value.toLowerCase();
+        for (const channel of context.channels.values()) {
+            for (const party of channel.parties) {
+                if (party.partyId === value || party.publicKeyDigest.toLowerCase() === lower) {
+                    return party.publicKeyDigest;
+                }
+            }
+        }
+        return value;
+    };
     const getRoute = async (raw) => {
         context.refreshRouting?.();
         const params = paramsObject(raw);
         const route = await context.routing.getRoute({
-            from: requiredString(params, 'fromPartyId'),
-            to: requiredString(params, 'toPartyId'),
+            from: normalizeRouteNode(requiredString(params, 'fromPartyId')),
+            to: normalizeRouteNode(requiredString(params, 'toPartyId')),
             amount: requiredBigInt(params, 'amount'),
             tokenId: requiredString(params, 'tokenId'),
             targetTokenId: typeof params.targetTokenId === 'string' ? params.targetTokenId : undefined,
@@ -304,7 +1724,10 @@ function createHostMethods(context) {
             address: context.identity.address,
             publicKeyDigest: context.identity.publicKeyDigest,
             identityId: context.identity.identityId,
+            settlementAddress: context.localParticipant?.settlementAddress,
             delegation: context.identity.delegation,
+            custodyMode: context.custodyMode ?? 'self',
+            p2pHubUrl: context.p2pHubUrl ?? null,
         };
     };
     register('totem_omniaWhoami', whoami, 'omnia/whoami');
@@ -317,8 +1740,14 @@ function createHostMethods(context) {
     register('totem_omniaGetManifest', getManifest, 'omnia/getManifest');
     // Fail-fast rule: without signing material only the read-only surface is
     // registered. Mutation methods must never exist without a signer.
+    // Coordinator mode: no host signing material. Expose the read surface plus
+    // the non-signing prepare/submit flow; wallets supply signatures and indices.
+    if (context.coordinator && !context.readOnly) {
+        registerPreparedPayMethods(methods, context);
+        return observeMethods(methods);
+    }
     if (context.readOnly || !context.signer || !context.leaseProvider) {
-        return methods;
+        return observeMethods(methods);
     }
     const openChannel = async (raw) => {
         const params = paramsObject(raw);
@@ -379,7 +1808,26 @@ function createHostMethods(context) {
                 if (typeof params.fundingScript === 'string') {
                     createParams.fundingScript = params.fundingScript;
                 }
-                createParams.fundingSigner = signer;
+                // If the caller supplied the funding coin's public key, the node's
+                // `sign` command is authoritative for that input. The host channel key
+                // must not sign someone else's funding coin.
+                createParams.fundingSigner = !fundingPubkey && context.signerPort && (context.custodyMode ?? 'self') !== 'hosted'
+                    ? async (digest) => context.signerPort.sign({
+                        requestId: `channel-funding-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+                        kind: 'chain',
+                        domain: 'channel',
+                        digest,
+                        context: { summary: 'Channel funding input' },
+                        signers: [context.signerPort.publicKeyDigest],
+                        custody: (0, omnia_1.makeSelfCustody)(),
+                        expiresAt: Date.now() + 60_000,
+                    })
+                    : signer;
+            }
+            // RFC-035: establish the peer transport before broadcasting funding.
+            // Otherwise a DHT timeout leaves the funding coin spent with no channel.
+            if (context.swarm) {
+                await context.swarm.connectToPeer(remote.publicKeyDigest, `omnia-open-preflight-${remotePartyId}`, remote.transportPubkey);
             }
             const created = await (0, omnia_1.createChannel)(createParams, context.chainProvider);
             context.channels.set(created.channel.channelId, {
@@ -393,6 +1841,17 @@ function createHostMethods(context) {
                 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';
             }
+            await context.observe?.emit({
+                domain: 'channel', kind: 'channel.opened', phase: 'accepted',
+                entity: { type: 'channel', id: created.channel.channelId },
+                parties: { local: context.localParticipant?.partyId, remote: remotePartyId },
+                token: { tokenId: created.channel.tokenId, scale: created.channel.tokenScale ?? 0 },
+                amounts: { capacity: created.channel.totalValue.toString(), balances: balancesJson(created.channel) },
+                chain: { fundingCoinId: created.channel.fundingCoinId, txpowId: created.channel.fundingTxId },
+                transitionHash: (0, emitter_js_1.channelTransitionHash)(created.channel),
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+                data: { acknowledged },
+            });
             return { success: true, channelId: created.channel.channelId, fundingTxId: created.channel.fundingTxId, acknowledged };
         });
         return result;
@@ -413,16 +1872,28 @@ function createHostMethods(context) {
                 throw new Error('Channel counterparty not found');
             if (amount <= 0n || (channel.balances[localPartyId] ?? 0n) < amount)
                 throw new Error('Insufficient channel balance');
+            const beforeBalances = balancesJson(channel);
             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);
+            }, context.leaseProvider, context.signer, context.signerPort);
             if (result.error)
                 throw new Error(result.error);
             context.channels.set(channelId, result.channel);
+            await context.observe?.emit({
+                domain: 'channel', kind: 'channel.updated', phase: 'committed',
+                entity: { type: 'channel', id: channelId },
+                parties: { local: localPartyId, remote: remotePartyId },
+                token: { tokenId: channel.tokenId, scale: channel.tokenScale ?? 0 },
+                before: { balances: beforeBalances, sequence: channel.currentSequence },
+                after: { balances: balancesJson(result.channel), sequence: result.channel.currentSequence },
+                amounts: { amountAtoms: amount.toString(), balances: balancesJson(result.channel) },
+                transitionHash: (0, emitter_js_1.channelTransitionHash)(result.channel),
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+            });
             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)
@@ -431,6 +1902,98 @@ function createHostMethods(context) {
         });
     };
     register('totem_omniaPay', pay, 'omnia/pay');
+    const sendHtlcState = async (channel, state) => {
+        const localPartyId = context.localParticipant.partyId;
+        const remote = channel.parties.find((party) => party.partyId !== localPartyId);
+        if (!context.swarm || !remote)
+            return;
+        const peer = context.channelPeers?.get(channel.channelId)
+            ?? await context.swarm.connectToPeer(remote.publicKeyDigest, channel.channelId, remote.transportPubkey);
+        await peer.sendMessage({ type: 'STATE_UPDATE', channelId: channel.channelId, nonce: Date.now(), payload: { ...state, pendingHTLCs: channel.pendingHTLCs } });
+    };
+    const addHtlcMethod = async (raw) => {
+        const params = paramsObject(raw);
+        const channelId = requiredString(params, 'channelId');
+        requireMutationContext(context);
+        const result = await withOperation(context, params, async () => {
+            const channel = context.channels.get(channelId);
+            if (!channel)
+                throw new Error(`Channel ${channelId} not found`);
+            const added = await (0, omnia_1.addHTLC)(channel, {
+                amount: requiredBigInt(params, 'amount'),
+                hashlock: requiredString(params, 'hashlock'),
+                timeoutBlock: requiredBigInt(params, 'timeoutBlock'),
+                direction: (typeof params.direction === 'string' ? params.direction : 'offered'),
+                counterpartPublicKeyDigest: requiredString(params, 'counterpartPublicKeyDigest'),
+            }, context.leaseProvider, context.signer);
+            if (added.error)
+                throw new Error(added.error);
+            context.channels.set(channelId, added.channel);
+            await context.observe?.emit({
+                domain: 'payment', kind: 'htlc.added', phase: 'committed',
+                entity: { type: 'channel', id: channelId },
+                amounts: { amountAtoms: requiredBigInt(params, 'amount').toString(), balances: balancesJson(added.channel) },
+                transitionHash: (0, emitter_js_1.channelTransitionHash)(added.channel),
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+                data: { htlcId: added.htlcId, hashlock: params.hashlock, timeoutBlock: String(params.timeoutBlock), direction: params.direction },
+            });
+            await sendHtlcState(added.channel, added.partialState);
+            return { success: true, channelId, htlcId: added.htlcId, sequence: added.channel.currentSequence };
+        });
+        return result;
+    };
+    register('totem_omniaAddHTLC', addHtlcMethod, 'omnia/addHTLC');
+    const fulfillHtlcMethod = async (raw) => {
+        const params = paramsObject(raw);
+        const channelId = requiredString(params, 'channelId');
+        requireMutationContext(context);
+        return withOperation(context, params, async () => {
+            const channel = context.channels.get(channelId);
+            if (!channel)
+                throw new Error(`Channel ${channelId} not found`);
+            const fulfilled = await (0, omnia_1.fulfillHTLC)(channel, requiredString(params, 'htlcId'), requiredString(params, 'preimage'), context.leaseProvider, context.signer);
+            if (fulfilled.error)
+                throw new Error(fulfilled.error);
+            context.channels.set(channelId, fulfilled.channel);
+            await context.observe?.emit({
+                domain: 'payment', kind: 'htlc.fulfilled', phase: 'committed',
+                entity: { type: 'channel', id: channelId },
+                amounts: { balances: balancesJson(fulfilled.channel) },
+                transitionHash: (0, emitter_js_1.channelTransitionHash)(fulfilled.channel),
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+                data: { htlcId: params.htlcId },
+            });
+            await sendHtlcState(fulfilled.channel, fulfilled.partialState);
+            return { success: true, channelId, sequence: fulfilled.channel.currentSequence };
+        });
+    };
+    register('totem_omniaFulfillHTLC', fulfillHtlcMethod, 'omnia/fulfillHTLC');
+    const timeoutHtlcMethod = async (raw) => {
+        const params = paramsObject(raw);
+        const channelId = requiredString(params, 'channelId');
+        requireMutationContext(context);
+        return withOperation(context, params, async () => {
+            const channel = context.channels.get(channelId);
+            if (!channel)
+                throw new Error(`Channel ${channelId} not found`);
+            const timedOut = await (0, omnia_1.timeoutHTLC)(channel, requiredString(params, 'htlcId'), context.leaseProvider, context.chainProvider, context.signer);
+            if (timedOut.error)
+                throw new Error(timedOut.error);
+            context.channels.set(channelId, timedOut.channel);
+            await context.observe?.emit({
+                domain: 'payment', kind: 'htlc.timed_out', phase: 'recovered',
+                entity: { type: 'channel', id: channelId },
+                amounts: { balances: balancesJson(timedOut.channel) },
+                transitionHash: (0, emitter_js_1.channelTransitionHash)(timedOut.channel),
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+                data: { htlcId: params.htlcId },
+            });
+            await sendHtlcState(timedOut.channel, timedOut.partialState);
+            return { success: true, channelId, sequence: timedOut.channel.currentSequence };
+        });
+    };
+    register('totem_omniaTimeoutHTLC', timeoutHtlcMethod, 'omnia/timeoutHTLC');
+    registerPreparedPayMethods(methods, context);
     const programTransition = async (raw) => {
         const params = paramsObject(raw);
         requireMutationContext(context);
@@ -523,6 +2086,14 @@ function createHostMethods(context) {
                 counterpartySignatures,
             });
             context.channels.set(channelId, (0, omnia_1.markChannelClosed)(closing));
+            await context.observe?.emit({
+                domain: 'settlement', kind: 'settlement.committed', phase: 'confirmed',
+                entity: { type: 'channel', id: channelId },
+                chain: { txpowId: settlement.settlementPayload.txpowId },
+                amounts: { balances: Object.fromEntries(Object.entries(settlement.settlementPayload.balances).map(([k, v]) => [k, v.toString()])) },
+                transitionHash: (0, emitter_js_1.hashTransition)(['settlement', channelId, settlement.settlementPayload.txpowId]),
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+            });
             return { success: true, channelId, settlementTxId: settlement.settlementPayload.txpowId, finalBalances: Object.fromEntries(Object.entries(settlement.settlementPayload.balances).map(([key, value]) => [key, value.toString()])) };
         });
     };
@@ -535,6 +2106,12 @@ function createHostMethods(context) {
             if (!channel)
                 throw new Error(`Channel ${channelId} not found`);
             context.channels.set(channelId, (0, omnia_1.markChannelClosed)(channel));
+            await context.observe?.emit({
+                domain: 'channel', kind: 'channel.closed', phase: 'closed',
+                entity: { type: 'channel', id: channelId },
+                transitionHash: (0, emitter_js_1.channelTransitionHash)((0, omnia_1.markChannelClosed)(channel)),
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+            });
             return { success: true, channelId };
         });
     };
@@ -567,24 +2144,38 @@ function createHostMethods(context) {
         if (!localBundle)
             throw new Error('No local factory lease bundle');
         const remote = parsed.find((participant) => participant.partyId !== localPartyId);
-        const localSigner = context.signer && context.leaseProvider
+        const localSigner = context.signerPort && (context.custodyMode ?? 'self') !== 'hosted'
             ? 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;
-                }
+                const request = {
+                    requestId: `factory-funding-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+                    kind: 'chain',
+                    domain: 'factory',
+                    digest,
+                    context: { summary: 'Factory funding input' },
+                    signers: [context.signerPort.publicKeyDigest],
+                    custody: (0, omnia_1.makeSelfCustody)(),
+                    expiresAt: Date.now() + 60_000,
+                };
+                return context.signerPort.sign(request);
             }
-            : undefined;
+            : 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) => {
@@ -656,6 +2247,14 @@ function createHostMethods(context) {
                 factory = accepted;
             }
             context.factories.set(factory.factoryId, factory);
+            await context.observe?.emit({
+                domain: 'factory', kind: 'factory.opened', phase: 'accepted',
+                entity: { type: 'factory', id: factory.factoryId },
+                amounts: { balances: Object.fromEntries(Object.entries(factory.allocations ?? {}).map(([k, v]) => [k, v.toString()])) },
+                transitionHash: (0, emitter_js_1.hashTransition)(['factory', factory.factoryId, factory.status]),
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+                data: { participants: factory.participants },
+            });
             return { success: true, factoryId: factory.factoryId, status: factory.status };
         });
     };
@@ -714,6 +2313,14 @@ function createHostMethods(context) {
             }
             context.factories.set(factoryId, result.factory);
             context.channels.set(result.channel.channelId, result.channel);
+            await context.observe?.emit({
+                domain: 'factory', kind: 'factory.vc_opened', phase: 'accepted',
+                entity: { type: 'channel', id: result.channel.channelId },
+                amounts: { capacity: result.channel.totalValue.toString(), balances: balancesJson(result.channel) },
+                transitionHash: (0, emitter_js_1.channelTransitionHash)(result.channel),
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+                data: { factoryId },
+            });
             return { success: true, channelId: result.channel.channelId, factoryId };
         });
     };
@@ -769,6 +2376,12 @@ function createHostMethods(context) {
             }
             context.factories.set(factoryId, updated);
             context.channels.delete(channelId);
+            await context.observe?.emit({
+                domain: 'factory', kind: 'factory.vc_closed', phase: 'closed',
+                entity: { type: 'channel', id: channelId },
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+                data: { factoryId, allocations: Object.fromEntries(Object.entries(updated.allocations ?? {}).map(([k, v]) => [k, v.toString()])) },
+            });
             return {
                 success: true,
                 factoryId,
@@ -831,6 +2444,13 @@ function createHostMethods(context) {
                 payload = await (0, omnia_factory_1.closeFactory)(factory, context.factoryBundles, context.chainProvider, { coinProof });
             }
             context.factories.set(factoryId, { ...factory, status: 'closed' });
+            await context.observe?.emit({
+                domain: 'factory', kind: 'factory.closed', phase: 'closed',
+                entity: { type: 'factory', id: factoryId },
+                chain: { txpowId: payload.txpowId },
+                amounts: { balances: Object.fromEntries(Object.entries(payload.finalAllocations).map(([k, v]) => [k, v.toString()])) },
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+            });
             const finalAllocations = payload.finalAllocations;
             return { success: true, factoryId, settlementTxId: payload.txpowId, finalAllocations: Object.fromEntries(Object.entries(finalAllocations).map(([key, value]) => [key, value.toString()])) };
         });
@@ -877,6 +2497,15 @@ function createHostMethods(context) {
                 proposerLeaseProvider: provider.wotsLease,
             });
             context.channels.set(channelId, spliced);
+            await context.observe?.emit({
+                domain: 'splice', kind: 'splice.completed', phase: 'confirmed',
+                entity: { type: 'channel', id: channelId },
+                amounts: { capacity: spliced.totalValue.toString(), balances: Object.fromEntries(Object.entries(spliced.balances).map(([k, v]) => [k, v.toString()])) },
+                chain: { fundingCoinId: spliced.spliceFundingCoinId, txpowId: spliced.spliceFundingTxId },
+                transitionHash: (0, emitter_js_1.hashTransition)(['splice', channelId, spliced.spliceFundingCoinId, spliced.spliceFundingTxId]),
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+                data: { spliceId: proposal.spliceId, spliceType: spliced.spliceType },
+            });
             await peer.sendMessage({
                 type: 'SPLICE_FINALIZED',
                 channelId,
@@ -943,6 +2572,18 @@ function createHostMethods(context) {
                 : await (0, omnia_router_1.executeMultiHopPayment)(ops, context.channels, parsedRoute, parsedRequest, leaseProviders);
             if (!result.success)
                 throw new Error(result.error ?? 'multi-hop payment failed');
+            await context.observe?.emit({
+                domain: 'payment', kind: 'payment.completed', phase: 'committed',
+                entity: { type: 'payment', id: typeof params.operationId === 'string' ? params.operationId : parsedRequest.hashlock },
+                ...(typeof params.operationId === 'string' ? { operationId: params.operationId } : {}),
+                amounts: { amountAtoms: parsedRequest.amount.toString() },
+                token: { tokenId: parsedRequest.tokenId, scale: 0 },
+                transitionHash: (0, emitter_js_1.hashTransition)(['payment', parsedRequest.hashlock, result.settledHops.join(',')]),
+                data: {
+                    settledHops: result.settledHops,
+                    hops: parsedRoute.hops.map((h) => ({ channelId: h.channelId, amount: String(h.amount) })),
+                },
+            });
             return {
                 success: true,
                 preimage: result.preimage,
@@ -951,5 +2592,5 @@ function createHostMethods(context) {
         });
     };
     register('totem_omniaPayMultiHop', payMultiHop, 'omnia/payMultiHop');
-    return methods;
+    return observeMethods(methods);
 }