@qorechain/chain-bridge 0.1.1 → 0.2.1

package/README.md

@@ -33,6 +33,7 @@ import { ChainBridge } from '@qorechain/chain-bridge';
 const bridge = new ChainBridge({
   cosmosRpc: process.env.QORE_RPC,          // http://node:26657
   chainId:   process.env.QORE_CHAIN_ID,     // qorechain-diana
+  cosmosRest: process.env.QORE_LCD,         // http://node:1317 — picks the PQC sign-bytes form
   evmRpc:    process.env.QORE_EVM_RPC,      // http://node:8545
   evmChainId: 9800,
   authorityMnemonic: process.env.LICENSE_AUTHORITY_MNEMONIC, // genesis license.authority
@@ -101,6 +102,38 @@ So the same mnemonic yields the **same** PQC key in every tool — recover it wi
 > and falls back to it automatically when a canonical signature is rejected.
 > Recover a legacy key with `recover-key … --derivation bridge`.
 
+## Hybrid sign-bytes form (v1 / v2, chain v3.2.0 / testnet v3.1.98)
+
+The ML-DSA-87 signature covers one of two byte forms, and a network accepts
+exactly one at any height:
+
+```
+v1 (legacy): BE32(len B0) ‖ B0 ‖ BE32(len A) ‖ A
+v2:          "qorechain-pqc-hybrid-v2" ‖ BE64(len chainId) ‖ chainId ‖ BE32(len B0) ‖ B0 ‖ BE32(len A) ‖ A
+```
+
+`qorechain-vladi` (mainnet) and `qorechain-diana` (testnet) verify v1 until the
+upgrade that carries the switch is applied on them and v2 afterwards; they upgrade
+at different heights (testnet is on v2; **mainnet stays on v1 until its own
+upgrade**). Any other chain verifies v2 from its first block.
+
+**Two plan names carry the same switch:** the release is `v3.2.0`, which is the
+name mainnet applies, while the testnet already applied it as `v3.1.98` and keeps
+that record. Either one applied means the network verifies v2, so the resolver
+asks for both.
+
+- `signBytesVersion: 'auto'` (default) asks `cosmosRest`
+  (`/cosmos/upgrade/v1beta1/applied_plan/v3.2.0`, then `/applied_plan/v3.1.98`;
+  v2 iff the numeric height of either is > 0, stopping at the first positive one)
+  and caches the answer for 60 s. On those two networks **`cosmosRest` is
+  required** — without it, or if a query fails, hybrid calls throw instead of guessing.
+- `signBytesVersion: 'v1' | 'v2'` pins the form (no query, no retry).
+- With `'auto'`, a refusal with `pqc` code 21 ("hybrid PQC signature verification
+  failed") re-resolves once and, if the network's answer changed, re-signs and
+  broadcasts once more. Only then does the legacy-key fallback (see the legacy note above) apply.
+
+Hybrid results carry `signBytesVersion`, the form used.
+
 ## Decimals
 
 - Cosmos lane (`uqor`): 6 decimals. `sendTokens` amounts are in `uqor`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qorechain/chain-bridge",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Server-side, autonomous bridge between Web2 backends (dashboards, exchanges) and the QoreChain on-chain modules. Grants licenses on-chain (PQC-signed), deploys contracts on the 3 VMs, registers light nodes, and moves QOR — all from a backend, no CLI.",
   "type": "module",
   "main": "src/index.js",
@@ -15,7 +15,7 @@
     "README.md"
   ],
   "scripts": {
-    "test": "node --test test/"
+    "test": "node --test"
   },
   "engines": {
     "node": ">=18"
@@ -24,7 +24,7 @@
     "@cosmjs/proto-signing": "^0.32.0",
     "@cosmjs/stargate": "^0.32.0",
     "@qorechain/pqc": "^0.1.1",
-    "@qorechain/wallet-adapter": "^0.1.4",
+    "@qorechain/wallet-adapter": "^0.2.1",
     "cosmjs-types": "^0.9.0",
     "ethers": "^6.13.0"
   },

package/src/cosmos.js

@@ -20,7 +20,8 @@ import { TxBody, AuthInfo, TxRaw, SignerInfo, ModeInfo, Fee } from 'cosmjs-types
 import { SignMode } from 'cosmjs-types/cosmos/tx/signing/v1beta1/signing.js';
 import { PubKey } from 'cosmjs-types/cosmos/crypto/secp256k1/keys.js';
 import {
-  frame, encodePqcHybridSignature, HYBRID_SIG_TYPE_URL, ALGORITHM_ML_DSA_87,
+  hybridSignBytes, resolveSignBytesVersion, isHybridSignBytesRejection,
+  encodePqcHybridSignature, HYBRID_SIG_TYPE_URL, ALGORITHM_ML_DSA_87,
   walletFromMnemonic, signClassicalEth, signHybridEth,
 } from '@qorechain/wallet-adapter';
 import { mldsa, shake256 } from '@qorechain/pqc';
@@ -61,9 +62,12 @@ export async function signerContext(mnemonic, prefix = 'qor', { keyType = 'secp2
   const pqc = mldsa.keygen(shake256(new TextEncoder().encode(`qorechain:pqc:v1|${acct.address}|${mnemonic}`), 32));
   // LEGACY fallback: pre-fix chain-bridge derived coin-118 PQC keys as
   // shake256(mnemonic) (no address binding). Accounts registered that way still
-  // hold that key on-chain, and the chain cannot rotate a key within the same
-  // algorithm — so keep the legacy key available; _submitHybridAuto falls back to
-  // it when the canonical signature is rejected.
+  // hold that key on-chain, so keep the legacy key available; _submitHybridAuto
+  // falls back to it when the canonical signature is rejected (code 21).
+  // NOTE: since chain v3.1.85 such an account CAN be migrated to the canonical
+  // key once, via MsgRotatePQCKey (tx pqc rotate-key / the wallet-adapter's
+  // rotatePqcKeyMsgFromMnemonic). After that the canonical signature matches and
+  // this fallback is never taken — the fallback stays only for un-rotated accounts.
   const pqcLegacy = mldsa.keygen(shake256(new TextEncoder().encode(mnemonic), 32));
   return { wallet, address: acct.address, pubkeySecp256k1: acct.pubkey, pqc, pqcLegacy };
 }
@@ -97,6 +101,7 @@ function assertOk(res, what) {
     const err = new Error(`${what} failed: code ${res.code}: ${res.rawLog || ''}`);
     err.code = res.code;
     err.rawLog = res.rawLog;
+    if (res.codespace) err.codespace = res.codespace;
     err.txHash = res.transactionHash;
     throw err;
   }
@@ -118,26 +123,65 @@ export function findEventAttr(events, eventType, attrKey) {
   return undefined;
 }
 
+// Sign-and-broadcast with the per-network sign-bytes form and the single retry.
+//
+// `sign(version)` builds TxRaw bytes for 'v1' | 'v2'; `broadcast(txBytes)` sends
+// them and returns a result or throws. The form is resolved with the wallet
+// adapter's resolveSignBytesVersion (explicit 'v1'/'v2' as given; 'auto' asks
+// `rest`). When the form was 'auto' and the chain refuses the hybrid signature
+// (codespace "pqc", code 21), the resolver is force-refreshed and, if the answer
+// changed, the tx is re-signed and broadcast ONCE more; any other outcome is
+// surfaced. Errors and results carry `signBytesVersion`.
+export async function broadcastHybridWithRetry({ chainId, rest, signBytesVersion = 'auto', fetch, sign, broadcast }) {
+  const mode = signBytesVersion ?? 'auto';
+  const resolveOpts = { chainId, rest, signBytesVersion: mode, ...(fetch ? { fetch } : {}) };
+  const version = await resolveSignBytesVersion(resolveOpts);
+  const tag = (x, v) => { if (x && typeof x === 'object') x.signBytesVersion = v; return x; };
+  try {
+    return tag(await broadcast(await sign(version)), version);
+  } catch (err) {
+    tag(err, version);
+    if (mode !== 'auto' || !isHybridSignBytesRejection(err)) throw err;
+    const fresh = await resolveSignBytesVersion({ ...resolveOpts, forceRefresh: true });
+    if (fresh === version) throw err; // the form was not the problem
+    try {
+      return tag(await broadcast(await sign(fresh)), fresh);
+    } catch (err2) {
+      throw tag(err2, fresh);
+    }
+  }
+}
+
 // Hybrid (PQC + classical) broadcast. messages: [{ typeUrl, value:Uint8Array }].
 // Mirrors the chain's `tx pqc cosign`:
 //   B0   = TxBody{messages, memo, timeoutHeight}            (no extension)
-//   sigP = ML-DSA-87(deterministic).sign( frame(B0, authInfo) )
+//   v    = 'v1' | 'v2' — the sign-bytes form this network verifies (see above)
+//   sigP = ML-DSA-87(deterministic).sign( hybridSignBytes(v, chainId, B0, authInfo) )
 //   body = TxBody{...B0, extensionOptions:[PQCHybridSignature{1, sigP}]}
 //   sigC = wallet.signDirect( SignDoc{body, authInfo, chainId, accountNumber} )
 //   tx   = TxRaw{ body, authInfo, [sigC] }
-export async function submitHybrid({ ctx, rpc, chainId, messages, gasLimit, gasPrice, memo = '', what = 'tx' }) {
+// `rest` (LCD URL) is required for signBytesVersion 'auto' on qorechain-vladi /
+// qorechain-diana; without it (and without an explicit version) this throws.
+export async function submitHybrid({
+  ctx, rpc, chainId, messages, gasLimit, gasPrice, memo = '', what = 'tx',
+  rest, signBytesVersion = 'auto', fetch,
+}) {
   return withClient(rpc, async (client) => {
     const acct = await client.getAccount(ctx.address);
     if (!acct) throw new Error(`account ${ctx.address} not found on-chain — fund it first`);
+    const broadcast = async (txBytes) => assertOk(await client.broadcastTx(txBytes), what);
 
     // eth-native path: delegate the whole build+sign to the wallet SDK (keccak
     // secp256k1 + ethsecp256k1 pubkey + ML-DSA-87 hybrid), then broadcast.
     if (ctx.ethNative) {
-      const txBytes = await signHybridEth({
-        key: ctx.ethKey, chainId, accountNumber: acct.accountNumber,
-        messages, fee: feeFor(gasLimit, gasPrice), sequence: acct.sequence, memo,
+      return broadcastHybridWithRetry({
+        chainId, rest, signBytesVersion, fetch, broadcast,
+        sign: (version) => signHybridEth({
+          key: ctx.ethKey, chainId, accountNumber: acct.accountNumber,
+          messages, fee: feeFor(gasLimit, gasPrice), sequence: acct.sequence, memo,
+          signBytesVersion: version,
+        }),
       });
-      return assertOk(await client.broadcastTx(txBytes), what);
     }
 
     const pubAny = {
@@ -153,23 +197,24 @@ export async function submitHybrid({ ctx, rpc, chainId, messages, gasLimit, gasP
       fee: Fee.fromPartial(feeFor(gasLimit, gasPrice)),
     });
     const authInfoBytes = AuthInfo.encode(authInfo).finish();
-
     const b0 = TxBody.encode(TxBody.fromPartial({ messages, memo, timeoutHeight: 0n })).finish();
-    // @qorechain/pqc >=0.1.1 signs deterministically (FIPS-204 §3.4) by default,
-    // as QoreChain's PQC ante verifier requires.
-    const pqcSig = mldsa.sign(ctx.pqc.secretKey, frame(b0, authInfoBytes));
-    const bodyBytes = TxBody.encode(TxBody.fromPartial({
-      messages, memo, timeoutHeight: 0n,
-      extensionOptions: [{ typeUrl: HYBRID_SIG_TYPE_URL, value: encodePqcHybridSignature(ALGORITHM_ML_DSA_87, pqcSig) }],
-    })).finish();
 
-    const { signature } = await ctx.wallet.signDirect(ctx.address, {
-      bodyBytes, authInfoBytes, chainId, accountNumber: BigInt(acct.accountNumber),
-    });
-    const classicalSig = typeof signature.signature === 'string'
-      ? Uint8Array.from(Buffer.from(signature.signature, 'base64')) : signature.signature;
-    const txBytes = TxRaw.encode(TxRaw.fromPartial({ bodyBytes, authInfoBytes, signatures: [classicalSig] })).finish();
-    return assertOk(await client.broadcastTx(txBytes), what);
+    const sign = async (version) => {
+      // @qorechain/pqc >=0.1.1 signs deterministically (FIPS-204 §3.4) by default,
+      // as QoreChain's PQC ante verifier requires.
+      const pqcSig = mldsa.sign(ctx.pqc.secretKey, hybridSignBytes(version, chainId, b0, authInfoBytes));
+      const bodyBytes = TxBody.encode(TxBody.fromPartial({
+        messages, memo, timeoutHeight: 0n,
+        extensionOptions: [{ typeUrl: HYBRID_SIG_TYPE_URL, value: encodePqcHybridSignature(ALGORITHM_ML_DSA_87, pqcSig) }],
+      })).finish();
+      const { signature } = await ctx.wallet.signDirect(ctx.address, {
+        bodyBytes, authInfoBytes, chainId, accountNumber: BigInt(acct.accountNumber),
+      });
+      const classicalSig = typeof signature.signature === 'string'
+        ? Uint8Array.from(Buffer.from(signature.signature, 'base64')) : signature.signature;
+      return TxRaw.encode(TxRaw.fromPartial({ bodyBytes, authInfoBytes, signatures: [classicalSig] })).finish();
+    };
+    return broadcastHybridWithRetry({ chainId, rest, signBytesVersion, fetch, sign, broadcast });
   });
 }
 

package/src/index.d.ts

@@ -3,7 +3,9 @@
 export interface ChainBridgeConfig {
   cosmosRpc: string;          // e.g. http://node:26657
   chainId: string;            // e.g. qorechain-diana
-  cosmosRest?: string;        // optional REST/LCD (:1317)
+  cosmosRest?: string;        // REST/LCD (:1317); required on qorechain-vladi / qorechain-diana for signBytesVersion 'auto'
+  signBytesVersion?: 'auto' | 'v1' | 'v2'; // hybrid PQC sign-bytes form, default 'auto' (asks cosmosRest)
+  fetch?: typeof globalThis.fetch;         // optional fetch used by the sign-bytes resolver
   evmRpc?: string;            // EVM JSON-RPC (:8545)
   evmChainId?: number;        // 9800 testnet / 9801 mainnet
   prefix?: string;            // bech32 prefix, default 'qor'
@@ -20,6 +22,7 @@ export interface TxResult {
   code: number;
   height?: number;
   gasUsed?: bigint;
+  signBytesVersion?: 'v1' | 'v2'; // hybrid sign-bytes form used (hybrid txs only)
 }
 
 export interface GrantSetResult {

package/src/index.js

@@ -106,6 +106,10 @@ export class ChainBridge {
     const args = {
       ctx, rpc: this.cfg.cosmosRpc, chainId: this.cfg.chainId,
       messages, gasLimit, gasPrice: this.cfg.gasPrice, memo, what,
+      // Sign-bytes form (v1/v2) per network: 'auto' asks cosmosRest; submitHybrid
+      // already re-resolves and retries once on a sign-bytes refusal.
+      rest: this.cfg.cosmosRest, signBytesVersion: this.cfg.signBytesVersion || 'auto',
+      ...(this.cfg.fetch ? { fetch: this.cfg.fetch } : {}),
     };
     try {
       return await submitHybrid(args);
@@ -113,7 +117,9 @@ export class ChainBridge {
       const log = String(err.rawLog || err.message || '');
       // (a) Legacy-derivation account: its on-chain PQC key was registered with the
       // old shake256(mnemonic) derivation, so the canonical signature is rejected
-      // (code 21). Retry with the legacy key. Checked FIRST — PQC_MISSING is broad
+      // (code 21). Retry with the legacy key. (A wrong sign-bytes form also yields
+      // code 21, but submitHybrid has already re-resolved the form and retried
+      // once, so reaching here means the form was right and the key is not.) Checked FIRST — PQC_MISSING is broad
       // and would otherwise also match this "…verification failed" message.
       if (ctx.pqcLegacy && !ctx.usedLegacy && /verification failed/i.test(log)) {
         return submitHybrid({ ...args, ctx: { ...ctx, pqc: ctx.pqcLegacy, usedLegacy: true } });