cold-join: rehydrate in-mem state, bind total_supply + burn amount in consensus

- A2: rehydrate the in-mem StateManager from the promoted CF after snapshot
  promote, fail-closed against the QC-bound macroblock state_root (fixes the
  first-tail-block empty-root wedge that stalled super-node onboarding).
- A1: settle the GALC pin before reading the snapshot ceiling so a cold joiner
  adopts the recent anchor, not the h=90 genesis anchor; skip the pin-wait
  below the first-capsule height.
- total_supply: bind into the QC Checkpoint (mirror registry_root); producer
  seals get_total_supply(), cold-join reads the QC-bound value instead of
  summing balances (correct at all epochs, fixes the emission-cap divergence).
- registered_nodes: rebuild from the snapshot-bound node_registry on cold-join
  so a joiner's dedup map matches a from-genesis node.
- burn attestation: sign the actual on-Solana burned amount and embed the
  2f+1-agreed cost + amount in the registration (consensus-bound Sybil floor).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: AIQnetLab

core/qnet-consensus/src/checkpoint_bft.rs

@@ -233,6 +233,13 @@ pub struct Checkpoint {
     /// node_registry — the source of cbw and attestor VRF keys — against this committed root,
     /// closing the forgeable-snapshot Sybil/fork vector.
     pub registry_root: Hash,
+    /// QC-signed total minted supply as of window_head_height. The apply-accumulated
+    /// emission total (genesis=0, monotonic +emit_rewards). QC-signed ⇒ 2f+1 certify it ⇒
+    /// a cold-joiner reads this QC-bound value instead of summing restored balances (which
+    /// diverges at epoch≥2 once rewards are minted-then-claimed-later). total_supply is
+    /// consensus-critical (emission cap) but not in state_root (account-only), so it is
+    /// bound separately here.
+    pub total_supply: u64,
     /// Proposer's wall-clock for this window (the head microblock's timestamp).
     /// In the QC-signed hash ⇒ agreed by the committee ⇒ every node seals an
     /// identical MacroBlock from the checkpoint (no producer dependency, no fork).
@@ -258,6 +265,7 @@ impl Checkpoint {
         h.update(self.epoch_commitment);
         h.update(self.reward_root);
         h.update(self.registry_root);
+        h.update(self.total_supply.to_le_bytes());
         h.update(self.timestamp.to_le_bytes());
         h.update(self.proposer.as_bytes());
         h.finalize().into()
@@ -427,7 +435,7 @@ mod tests {
         let mut c = Checkpoint {
             index: 1, parent_qc: None, window_head_height: 90,
             window_mb_hashes: vec![h(1), h(2)], state_root: h(3),
-            beacon: h(4), epoch_commitment: h(0), reward_root: h(0), registry_root: h(0), timestamp: 0, proposer: "n1".into(), proposer_sig: vec![1,2,3],
+            beacon: h(4), epoch_commitment: h(0), reward_root: h(0), registry_root: h(0), total_supply: 0, timestamp: 0, proposer: "n1".into(), proposer_sig: vec![1,2,3],
         };
         let x = c.hash();
         c.proposer_sig = vec![9, 9, 9];   // sig change must NOT change hash
@@ -444,6 +452,23 @@ mod tests {
         assert_ne!(a.hash(), b.hash());
     }
 
+    #[test]
+    fn checkpoint_hash_binds_total_supply() {
+        // total_supply MUST be bound into the QC-signed hash: a cold-joiner trusts this value
+        // (2f+1 certify it) instead of summing balances, so a checkpoint differing only in
+        // total_supply must produce a different hash. Otherwise stable + deterministic.
+        let c = Checkpoint {
+            index: 1, parent_qc: None, window_head_height: 90,
+            window_mb_hashes: vec![h(1), h(2)], state_root: h(3),
+            beacon: h(4), epoch_commitment: h(0), reward_root: h(0), registry_root: h(0), total_supply: 1_000_000, timestamp: 0, proposer: "n1".into(), proposer_sig: vec![1,2,3],
+        };
+        let base = c.hash();
+        assert_eq!(c.hash(), base, "hash must be deterministic for fixed fields");
+        let mut d = c.clone();
+        d.total_supply = 2_000_000;        // value change MUST change hash
+        assert_ne!(d.hash(), base, "total_supply must be in the QC-signed hash");
+    }
+
     #[test]
     fn merkle_root_deterministic_and_sensitive() {
         let a = vec![vec![1u8,2], vec![3,4], vec![5,6]];
@@ -609,7 +634,7 @@ mod tests {
         let child = Checkpoint {
             index: 5, parent_qc: Some(parent_qc), window_head_height: 450,
             window_mb_hashes: vec![h(1)], state_root: h(2), beacon: h(3),
-            epoch_commitment: h(0), reward_root: h(0), registry_root: h(0), timestamp: 0, proposer: "n0".into(), proposer_sig: vec![],
+            epoch_commitment: h(0), reward_root: h(0), registry_root: h(0), total_supply: 0, timestamp: 0, proposer: "n0".into(), proposer_sig: vec![],
         };
         let child_qc = mk_qc(&committee, child.hash(), 5, 3);
         assert_eq!(commits_parent(&child, &child_qc), Some(4)); // C4 final
@@ -625,7 +650,7 @@ mod tests {
         let c = Checkpoint {
             index: 7, parent_qc: Some(qc.clone()), window_head_height: 630,
             window_mb_hashes: vec![h(1), h(2)], state_root: h(3), beacon: h(4),
-            epoch_commitment: h(0), reward_root: h(0), registry_root: h(0), timestamp: 0, proposer: "n1".into(), proposer_sig: vec![1,2,3],
+            epoch_commitment: h(0), reward_root: h(0), registry_root: h(0), total_supply: 0, timestamp: 0, proposer: "n1".into(), proposer_sig: vec![1,2,3],
         };
         let bytes = bincode::serialize(&c).unwrap();
         let back: Checkpoint = bincode::deserialize(&bytes).unwrap();

core/qnet-consensus/src/checkpoint_consensus.rs

@@ -229,7 +229,7 @@ mod tests {
         Checkpoint {
             index, parent_qc, window_head_height: index * 10,
             window_mb_hashes: vec![hh(index as u8)], state_root: hh(index as u8),
-            beacon: hh(0), epoch_commitment: hh(0), reward_root: hh(0), registry_root: hh(0), timestamp: 0, proposer: c[li].clone(), proposer_sig: Vec::new(),
+            beacon: hh(0), epoch_commitment: hh(0), reward_root: hh(0), registry_root: hh(0), total_supply: 0, timestamp: 0, proposer: c[li].clone(), proposer_sig: Vec::new(),
         }
     }
 

core/qnet-state/src/state.rs

@@ -1186,6 +1186,15 @@ impl StateManager {
         self.registered_nodes.insert(node_id.to_string(), wallet_address.to_string());
     }
 
+    /// Cold-join: seed one chain-confirmed node_id->wallet binding into `registered_nodes` from the
+    /// snapshot-bound node_registry CF (the integration layer reads the CF and calls this per entry).
+    /// Same insert as mark_node_registered; named distinctly so the cold-join rehydrate intent is
+    /// explicit. The crate boundary forbids qnet-state reading the integration Storage type, so the
+    /// read lives integration-side and only the inserter is here.
+    pub fn seed_registered_node(&self, node_id: &str, wallet_address: &str) {
+        self.registered_nodes.insert(node_id.to_string(), wallet_address.to_string());
+    }
+
     /// Get the wallet address for a registered node (None if not registered)
     pub fn get_node_wallet(&self, node_id: &str) -> Option<String> {
         self.registered_nodes.get(node_id).map(|v| v.clone())

core/qnet-state/src/transaction.rs

@@ -353,16 +353,20 @@ pub enum TransactionType {
         #[serde(default)]
         api_endpoint: String,
         /// Phase-1 proof-of-burn carrier. The external Solana 1DEV burn is non-deterministic (live
-        /// RPC) and cannot be re-checked in apply, so the burn fact is brought ON-CHAIN as a genesis
-        /// quorum: `burn_attestors` carries ≥2f+1 distinct genesis Dilithium signatures over
-        /// `burn_attestation_message(burn_tx, wallet_address, burn_amount, node_type)`, re-verified
-        /// from these bytes at block validation (deterministic, snapshot-independent). Empty for
-        /// genesis identities (registration_proof=="genesis") and when the gate is inactive.
+        /// RPC) and cannot be re-checked in apply, so the burn fact is brought ON-CHAIN as a committee
+        /// quorum: `burn_attestors` carries ≥2f+1 distinct committee Dilithium signatures over
+        /// `burn_attestation_message(burn_tx, wallet_address, burn_amount, node_type, burn_cost)`,
+        /// re-verified from these bytes at block validation (deterministic, snapshot-independent).
+        /// Empty for genesis identities (registration_proof=="genesis") and when the gate is inactive.
         #[serde(default)]
         burn_tx: String,
         #[serde(default)]
         burn_amount: u64,
-        /// (genesis_id, dilithium_sig) attestation quorum. Verified, never trusted blindly.
+        /// Required Phase-1 cost the committee attested (whole 1DEV). Carried so the verifier rebuilds
+        /// the exact signed message + asserts burn_amount >= burn_cost with NO Solana re-read.
+        #[serde(default)]
+        burn_cost: u64,
+        /// (committee_id, dilithium_sig) attestation quorum. Verified, never trusted blindly.
         #[serde(default)]
         burn_attestors: Vec<(String, String)>,
     },
@@ -876,17 +880,37 @@ impl Transaction {
     /// Consistent with `compute_gas_used() == 0` for every variant listed
     /// below (except NodeActivation which uses `gas_limits::NODE_ACTIVATION`
     /// for metering purposes but is still a system TX).
-    /// Canonical message a genesis node signs to attest a Phase-1 Solana 1DEV burn backing a node
-    /// registration. FIXED format (pipe-joined, node_type as a stable integer) so all genesis sign
+    /// Canonical message a committee member signs to attest a Phase-1 Solana 1DEV burn backing a node
+    /// registration. FIXED format (pipe-joined, node_type as a stable integer) so all signers produce
     /// identical bytes and every validator recomputes the identical message at block validation —
-    /// no float / locale / map-iteration input. Binds the burn tx, beneficiary wallet, amount and
-    /// node type, so a quorum signature is valid for exactly one (burn, wallet, amount, type) tuple.
-    pub fn burn_attestation_message(burn_tx: &str, wallet: &str, amount: u64, node_type: &NodeType) -> String {
+    /// no float / locale / map-iteration input. Binds the burn tx, beneficiary wallet, amount, node
+    /// type AND the required Phase-1 cost, so a quorum signature is valid for exactly one
+    /// (burn, wallet, amount, type, cost) tuple. The `cost` lives INSIDE the 2f+1-signed message so
+    /// every validator agrees on it by signature-verification, never by re-reading Solana.
+    pub fn burn_attestation_message(burn_tx: &str, wallet: &str, amount: u64, node_type: &NodeType, cost: u64) -> String {
         let nt: u8 = match node_type {
             NodeType::Super => 0,
             NodeType::Light => 1,
         };
-        format!("burn_attest:{}:{}:{}:{}", burn_tx, wallet, amount, nt)
+        format!("burn_attest:{}:{}:{}:{}:{}", burn_tx, wallet, amount, nt, cost)
+    }
+
+    /// Deterministic Phase-1 super/light activation cost in whole 1DEV, computed with INTEGER math so
+    /// every node agrees (the f64 burn_percentage diverges across nodes). Mirrors the off-chain
+    /// formula `max(1500 - 150*floor(burn_pct/10), 300)`: base 1500, −150 per complete 10% of the
+    /// 1DEV supply burned, floored at 300. Universal Light=Super in Phase 1.
+    /// `burn_pct_tenths` = burn% to one decimal; `tiers` = each complete 10% (capped at 8 → floor 300).
+    /// Bucketing to 10% means members reading Solana at slightly different times still agree on the
+    /// cost except exactly at a 10% boundary (there the registration just retries — a liveness hiccup,
+    /// not a fork).
+    pub fn phase1_activation_cost(total_burned: u64, current_supply: u64) -> u64 {
+        // burn% = burned / ORIGINAL supply; original = burned + current(remaining). Denominator is their
+        // SUM, not the remaining alone (else 50% burned would read as 100%). current_supply is the live
+        // Solana getTokenSupply (remaining); the sum reconstructs the original cap.
+        let original = total_burned.saturating_add(current_supply);
+        let burn_pct_tenths = if original == 0 { 0 } else { total_burned * 1000 / original };
+        let tiers = burn_pct_tenths / 100; // each complete 10%
+        1500u64.saturating_sub(150 * tiers.min(8)).max(300)
     }
 
     pub fn is_system_tx(&self) -> bool {
@@ -3444,20 +3468,35 @@ mod tests_v34_heartbeat {
         assert_eq!(accts.get("super_y").unwrap().heartbeat_slots.count_ones(), 9);
     }
 
-    // Burn-attestation canonical message: FIXED, deterministic, type-distinct — every genesis signs
-    // identical bytes and every validator recomputes the identical message, so the quorum verdict is
-    // byte-identical network-wide. Drift here would split the genesis signatures ⇒ no quorum forms.
+    // Burn-attestation canonical message: FIXED, deterministic, type-distinct — every committee member
+    // signs identical bytes and every validator recomputes the identical message, so the quorum verdict
+    // is byte-identical network-wide. Drift here would split the signatures ⇒ no quorum forms.
     #[test]
     fn burn_attestation_message_is_canonical_and_type_distinct() {
-        let m = Transaction::burn_attestation_message("solSig", "walletA", 1500, &NodeType::Super);
-        assert_eq!(m, Transaction::burn_attestation_message("solSig", "walletA", 1500, &NodeType::Super), "deterministic");
-        assert_eq!(m, "burn_attest:solSig:walletA:1500:0", "fixed format, Super=0");
-        // Every bound field (incl. node_type) changes the signed message.
-        assert_ne!(m, Transaction::burn_attestation_message("solSig", "walletA", 1500, &NodeType::Light));
-        assert_ne!(m, Transaction::burn_attestation_message("solSig", "walletA", 1501, &NodeType::Super));
-        assert_ne!(m, Transaction::burn_attestation_message("solSig", "walletB", 1500, &NodeType::Super));
-        assert_ne!(m, Transaction::burn_attestation_message("solSig2", "walletA", 1500, &NodeType::Super));
-        assert_eq!(Transaction::burn_attestation_message("x", "y", 0, &NodeType::Light), "burn_attest:x:y:0:1", "Light=1");
+        let m = Transaction::burn_attestation_message("solSig", "walletA", 1500, &NodeType::Super, 1500);
+        assert_eq!(m, Transaction::burn_attestation_message("solSig", "walletA", 1500, &NodeType::Super, 1500), "deterministic");
+        assert_eq!(m, "burn_attest:solSig:walletA:1500:0:1500", "fixed format, Super=0, cost suffix");
+        // Every bound field (incl. node_type and cost) changes the signed message.
+        assert_ne!(m, Transaction::burn_attestation_message("solSig", "walletA", 1500, &NodeType::Light, 1500));
+        assert_ne!(m, Transaction::burn_attestation_message("solSig", "walletA", 1501, &NodeType::Super, 1500));
+        assert_ne!(m, Transaction::burn_attestation_message("solSig", "walletB", 1500, &NodeType::Super, 1500));
+        assert_ne!(m, Transaction::burn_attestation_message("solSig2", "walletA", 1500, &NodeType::Super, 1500));
+        assert_ne!(m, Transaction::burn_attestation_message("solSig", "walletA", 1500, &NodeType::Super, 1350), "cost is bound");
+        assert_eq!(Transaction::burn_attestation_message("x", "y", 0, &NodeType::Light, 300), "burn_attest:x:y:0:1:300", "Light=1");
+    }
+
+    // Phase-1 cost formula: integer-deterministic, matching max(1500 - 150*floor(burn_pct/10), 300).
+    #[test]
+    fn phase1_activation_cost_tiers() {
+        // Args are (total_burned, current_remaining) as Solana reports them; the fn reconstructs the
+        // original cap = burned + remaining. Original 1DEV cap = 1B.
+        let orig = 1_000_000_000u64;
+        assert_eq!(Transaction::phase1_activation_cost(0, orig), 1500, "0% burned ⇒ base 1500");
+        assert_eq!(Transaction::phase1_activation_cost(orig / 10, orig - orig / 10), 1350, "10% ⇒ −150");
+        assert_eq!(Transaction::phase1_activation_cost(orig / 2, orig - orig / 2), 750, "50% ⇒ −750");
+        assert_eq!(Transaction::phase1_activation_cost(orig * 8 / 10, orig - orig * 8 / 10), 300, "80% ⇒ floor 300");
+        assert_eq!(Transaction::phase1_activation_cost(orig * 95 / 100, orig - orig * 95 / 100), 300, "95% ⇒ floored 300");
+        assert_eq!(Transaction::phase1_activation_cost(0, 0), 1500, "zero original ⇒ base (no div-by-zero)");
     }
 
     // Structural validation (the pure part; anchor/sig are checked at block validation).

development/qnet-integration/src/consensus_v2_driver.rs

@@ -122,7 +122,7 @@ impl ConsensusDriver {
         &mut self, window: u64, mb_hashes: Vec<Hash>,
         state_root: Hash, beacon: Hash, head_ts: u64,
         committee: Vec<NodeId>, eligible_producers: Vec<u8>, banned: Vec<NodeId>, reward_root: Hash,
-        registry_root: Hash,
+        registry_root: Hash, total_supply: u64,
     ) -> Vec<Effect> {
         self.set_committee(committee.clone());
         let round = self.eng.current_index;
@@ -140,7 +140,7 @@ impl ConsensusDriver {
         let head_height = window.saturating_mul(self.cp_interval);
         let cp = Checkpoint {
             index: round, parent_qc: self.eng.high_qc.clone(), window_head_height: head_height,
-            window_mb_hashes: mb_hashes, state_root, beacon, epoch_commitment: epoch_c, reward_root, registry_root, timestamp: head_ts,
+            window_mb_hashes: mb_hashes, state_root, beacon, epoch_commitment: epoch_c, reward_root, registry_root, total_supply, timestamp: head_ts,
             proposer: self.node_id.clone(), proposer_sig: Vec::new(),
         };
         self.last_proposed_round = round;
@@ -313,7 +313,7 @@ mod tests {
         for index in 1..=8u64 {
             let mut seed = Vec::new();
             for k in 0..nodes.len() {
-                let effs = nodes[k].d.build_proposal(index, vec![[index as u8; 32]], [index as u8; 32], [0u8; 32], index * 1000, c.clone(), Vec::new(), Vec::new(), [0u8; 32], [0u8; 32]);
+                let effs = nodes[k].d.build_proposal(index, vec![[index as u8; 32]], [index as u8; 32], [0u8; 32], index * 1000, c.clone(), Vec::new(), Vec::new(), [0u8; 32], [0u8; 32], 0);
                 for e in effs { seed.extend(exec(&mut nodes[k], e)); }
             }
             deliver(&mut nodes, &c, seed);
@@ -341,7 +341,7 @@ mod tests {
         for index in 1..=6u64 {
             let mut seed = Vec::new();
             for k in 0..nodes.len() {
-                let effs = nodes[k].d.build_proposal(index, vec![[index as u8; 32]], [index as u8; 32], [0u8; 32], index * 1000, c.clone(), Vec::new(), Vec::new(), [0u8; 32], [0u8; 32]);
+                let effs = nodes[k].d.build_proposal(index, vec![[index as u8; 32]], [index as u8; 32], [0u8; 32], index * 1000, c.clone(), Vec::new(), Vec::new(), [0u8; 32], [0u8; 32], 0);
                 for e in effs { seed.extend(exec(&mut nodes[k], e)); }
             }
             deliver(&mut nodes, &c, seed);
@@ -360,7 +360,7 @@ mod tests {
         let c: Vec<NodeId> = (0..4).map(|i| format!("n{}", i)).collect();
         let cp = Checkpoint {
             index: 1, parent_qc: None, window_head_height: 10, window_mb_hashes: vec![[1u8; 32]],
-            state_root: [1u8; 32], beacon: [0u8; 32], epoch_commitment: [0u8; 32], reward_root: [0u8; 32], registry_root: [0u8; 32], timestamp: 0, proposer: "n1".into(), proposer_sig: vec![9, 9],
+            state_root: [1u8; 32], beacon: [0u8; 32], epoch_commitment: [0u8; 32], reward_root: [0u8; 32], registry_root: [0u8; 32], total_supply: 0, timestamp: 0, proposer: "n1".into(), proposer_sig: vec![9, 9],
         };
         // forged proposer_sig fails node verify ⇒ never reaches the driver
         assert!(!verify_msg(&c, &ConsensusMsg::Proposal(cp)));
@@ -383,7 +383,7 @@ mod tests {
         fn step(nodes: &mut Vec<Node>, c: &[NodeId], w: u64) {
             let mut seed = Vec::new();
             for k in 0..nodes.len() {
-                let effs = nodes[k].d.build_proposal(w, vec![[w as u8; 32]], [w as u8; 32], [0u8; 32], w * 1000, c.to_vec(), Vec::new(), Vec::new(), [0u8; 32], [0u8; 32]);
+                let effs = nodes[k].d.build_proposal(w, vec![[w as u8; 32]], [w as u8; 32], [0u8; 32], w * 1000, c.to_vec(), Vec::new(), Vec::new(), [0u8; 32], [0u8; 32], 0);
                 for e in effs { seed.extend(exec(&mut nodes[k], e)); }
             }
             deliver(nodes, c, seed);
@@ -427,7 +427,7 @@ mod tests {
             let cp = Checkpoint {
                 index: i, parent_qc: prev_qc.clone(), window_head_height: i * 90,
                 window_mb_hashes: vec![[i as u8; 32]], state_root: [i as u8; 32],
-                beacon: [0u8; 32], epoch_commitment: [0u8; 32], reward_root: [0u8; 32], registry_root: [0u8; 32], timestamp: 0,
+                beacon: [0u8; 32], epoch_commitment: [0u8; 32], reward_root: [0u8; 32], registry_root: [0u8; 32], total_supply: 0, timestamp: 0,
                 proposer: c[leader_index(i, &parent_hash, c.len())].clone(), proposer_sig: Vec::new(),
             };
             let signers: Vec<NodeId> = c.iter().take(3).cloned().collect();