@totemsdk/omnia-host 0.8.0 → 0.9.0

package/dist/api/jsonrpc.js

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

package/dist/api/methods.d.ts

@@ -17,6 +17,12 @@ export interface HostApiContext {
     chainProvider?: ChainStateProvider;
     swarm?: OmniaSwarm;
     localParticipant?: ChannelParticipant;
+    /**
+     * Signs the funding-transaction digest with the funding coin's key, so
+     * openChannel can assemble the funding witness without the caller reproducing
+     * the funding draft. Configured from the node's `sign` command.
+     */
+    fundingSigner?: (digest: Uint8Array) => Promise<Uint8Array> | Uint8Array;
     factories?: Map<string, ChannelFactory>;
     factoryBundles?: Record<string, WotsLeaseBundle>;
     spliceProposals?: Map<string, SpliceProposal>;

package/dist/api/methods.js

@@ -48,8 +48,10 @@ function channelStateView(channel) {
         totalValue: channel.totalValue,
         currentSequence: channel.currentSequence,
         fundingAddress: channel.fundingAddress,
+        fundingScript: channel.fundingScript,
         fundingTxId: channel.fundingTxId,
         fundingCoinId: channel.fundingCoinId,
+        contestDelayBlocks: channel.contestDelayBlocks,
         parties: channel.parties,
         balances: channel.balances,
         pendingHTLCs: channel.pendingHTLCs,
@@ -184,6 +186,32 @@ async function persistProgramUpdate(context, channelId, run) {
         balances: balancesJson(result.channel),
     };
 }
+/**
+ * Wait for an ACK/ERROR from the counterparty for a given channel. Returns the
+ * reply message (so callers can read a co-signature) or null on timeout.
+ */
+function waitForPeerReply(peer, channelId, timeoutMs) {
+    return new Promise((resolve) => {
+        let done = false;
+        let unsub;
+        const finish = (reply) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (unsub)
+                unsub();
+            resolve(reply);
+        };
+        unsub = peer.onMessage((msg) => {
+            if (msg.channelId !== channelId)
+                return;
+            if (msg.type === 'ACK' || msg.type === 'ERROR')
+                finish(msg);
+        });
+        const timer = setTimeout(() => finish(null), timeoutMs);
+    });
+}
 function createHostMethods(context) {
     const methods = new Map();
     const register = (name, handler, alias) => {
@@ -285,18 +313,58 @@ function createHostMethods(context) {
                 remoteAmount: requiredBigInt(params, 'remoteAmount'),
                 tokenId: typeof params.tokenId === 'string' ? params.tokenId : undefined,
                 fundingCoinId: requiredString(params, 'fundingCoinId'),
-                fundingWitnessBytes: Buffer.from(requiredString(params, 'fundingWitnessHex').replace(/^0x/i, ''), 'hex'),
+                contestDelayBlocks: typeof params.contestDelayBlocks === 'number' ? params.contestDelayBlocks : undefined,
             };
+            const fundingWitnessHex = typeof params.fundingWitnessHex === 'string' ? params.fundingWitnessHex : undefined;
+            if (fundingWitnessHex) {
+                createParams.fundingWitnessBytes = Buffer.from(fundingWitnessHex.replace(/^0x/i, ''), 'hex');
+            }
+            else {
+                // Assemble the funding witness: createChannel builds the funding draft,
+                // a funding signer signs its digest, and the caller supplies the input
+                // proofs (serialized CoinProof + ScriptProof). The signer comes from the
+                // configured funding signer, or from the node's `sign` command using the
+                // `fundingPubkey` the caller passes.
+                const fundingPubkey = typeof params.fundingPubkey === 'string' ? params.fundingPubkey : undefined;
+                const nodeAdapter = context.chainProvider;
+                const signer = context.fundingSigner ?? (fundingPubkey && typeof nodeAdapter?.signData === 'function'
+                    ? async (digest) => {
+                        const sig = await nodeAdapter.signData(fundingPubkey, '0x' + Buffer.from(digest).toString('hex'));
+                        return Uint8Array.from(Buffer.from(sig.replace(/^0x/i, ''), 'hex'));
+                    }
+                    : undefined);
+                if (!signer) {
+                    throw new Error('openChannel requires fundingWitnessHex, or a fundingPubkey + funding proofs');
+                }
+                if (typeof params.fundingScript !== 'string' && !Array.isArray(params.fundingScriptProofsHex)) {
+                    throw new Error('openChannel requires fundingScript (or serialized fundingScriptProofsHex) for the funding input address');
+                }
+                const toBytes = (v) => Array.isArray(v) ? v.map((h) => Buffer.from(String(h).replace(/^0x/i, ''), 'hex')) : [];
+                createParams.fundingProofs = {
+                    coinProofs: toBytes(params.fundingCoinProofsHex),
+                    scriptProofs: toBytes(params.fundingScriptProofsHex),
+                };
+                // The funding coin's address script: createChannel derives the required
+                // single-leaf ScriptProof from it, so callers need not hand-roll it.
+                if (typeof params.fundingScript === 'string') {
+                    createParams.fundingScript = params.fundingScript;
+                }
+                createParams.fundingSigner = signer;
+            }
             const created = await (0, omnia_1.createChannel)(createParams, context.chainProvider);
             context.channels.set(created.channel.channelId, {
                 ...created.channel,
                 localSigner: context.signer,
             });
+            let acknowledged = true;
             if (context.swarm) {
                 const peer = await context.swarm.connectToPeer(remote.publicKeyDigest, created.channel.channelId);
                 await peer.sendMessage({ type: 'CHANNEL_PROPOSAL', channelId: created.channel.channelId, nonce: Date.now(), payload: created.proposal });
+                // Give the peer time to accept so a follow-up pay() is not lost.
+                const reply = await waitForPeerReply(peer, created.channel.channelId, 20_000);
+                acknowledged = reply?.type === 'ACK';
             }
-            return { success: true, channelId: created.channel.channelId, fundingTxId: created.channel.fundingTxId };
+            return { success: true, channelId: created.channel.channelId, fundingTxId: created.channel.fundingTxId, acknowledged };
         });
         return result;
     };
@@ -387,11 +455,43 @@ function createHostMethods(context) {
             if (!channel)
                 throw new Error(`Channel ${channelId} not found`);
             const closing = (0, omnia_1.markChannelClosing)(channel, 'mutual');
+            const partyAddresses = Object.fromEntries(closing.parties.map((party) => [party.partyId, party.settlementAddress ?? party.publicKeyDigest]));
+            // Cooperative close needs both eltoo MULTISIG(2 A B) signatures. Build the
+            // exact settlement draft, ask the counterparty to co-sign it, then include
+            // both signatures in the broadcast witness.
+            const localPartyId = context.localParticipant?.partyId;
+            const remoteParty = localPartyId
+                ? closing.parties.find((party) => party.partyId !== localPartyId)
+                : undefined;
+            let counterpartySignatures;
+            let settlementTxHex;
+            if (context.swarm && remoteParty) {
+                const request = (0, omnia_1.buildSettlementSigningRequest)(closing, { partyAddresses });
+                const peer = await context.swarm.connectToPeer(remoteParty.publicKeyDigest, channelId);
+                await peer.sendMessage({
+                    type: 'SETTLEMENT_PROPOSAL',
+                    channelId,
+                    nonce: Date.now(),
+                    payload: { signRequest: true, ...request },
+                });
+                const reply = await waitForPeerReply(peer, channelId, 30_000);
+                const replyPayload = reply?.payload;
+                if (reply?.type !== 'ACK' || typeof replyPayload?.signature !== 'string') {
+                    throw new Error(`Counterparty did not co-sign the settlement (${reply?.type ?? 'timeout'})`);
+                }
+                counterpartySignatures = [{
+                        partyId: replyPayload.partyId ?? remoteParty.partyId,
+                        signature: Buffer.from(replyPayload.signature.replace(/^0x/i, ''), 'hex'),
+                    }];
+                settlementTxHex = request.settlementTxHex;
+            }
             const settlement = await (0, omnia_1.proposeSettlement)(closing, context.leaseProvider, {
                 signer: context.signer,
                 chainProvider: context.chainProvider,
                 broadcastProofs: parsedProofs,
-                partyAddresses: Object.fromEntries(closing.parties.map((party) => [party.partyId, party.settlementAddress ?? party.publicKeyDigest])),
+                partyAddresses,
+                settlementTxHex,
+                counterpartySignatures,
             });
             context.channels.set(channelId, (0, omnia_1.markChannelClosed)(closing));
             return { success: true, channelId, settlementTxId: settlement.settlementPayload.txpowId, finalBalances: Object.fromEntries(Object.entries(settlement.settlementPayload.balances).map(([key, value]) => [key, value.toString()])) };

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

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

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

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

package/dist/config.d.ts

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

package/dist/config.js

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

package/dist/lifecycle.js

@@ -107,6 +107,12 @@ function createOmniaHost(config, dependencies = {}) {
                         spliceProposals: dependencies.spliceProposals,
                         spliceAcceptances: dependencies.spliceAcceptances,
                         spliceLeaseProvider: dependencies.spliceLeaseProvider,
+                        fundingSigner: config.fundingPubkey
+                            ? async (digest) => {
+                                const sig = await chainAdapter.signData(config.fundingPubkey, '0x' + Buffer.from(digest).toString('hex'));
+                                return Uint8Array.from(Buffer.from(sig.replace(/^0x/i, ''), 'hex'));
+                            }
+                            : undefined,
                         readOnly,
                         identity: dependencies.identity,
                         manifest: dependencies.manifest,

package/package.json

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