From 5cd416e49ee2b7528cec34c2ca58f5215cae452e Mon Sep 17 00:00:00 2001
From: Federico Franzoni <8609060+fed-franz@users.noreply.github.com>
Date: Thu, 13 Jun 2024 16:17:52 +0200
Subject: [PATCH 1/7] consensus: Rename most_recent_block (mrb) to tip

---
 consensus/README.md         |  8 ++++----
 consensus/src/aggregator.rs |  6 +++---
 consensus/src/commons.rs    | 10 +++++-----
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/consensus/README.md b/consensus/README.md
index b733a19263..8f98ceb267 100644
--- a/consensus/README.md
+++ b/consensus/README.md
@@ -47,15 +47,15 @@ let mut consensus = Consensus::new(
 	Arc::new(Mutex::new(crate::mocks::SimpleDB::default())),
 );
 
-let mut most_recent_block = Block::default();
+let mut tip = Block::default();
 
 loop {
 	/// Provisioners list is retrieved from contract storage state.
 	let provisioners = rusk::get_provisioners();
 
 	// Round update is the input data for any consensus round execution.
-	// Round update includes mostly data from most recent block. 
-	let round_update = from(most_recent_block);
+	// Round update includes mostly data from the tip. 
+	let round_update = from(tip);
 
 	/// Consensus::Spin call initializes a consensus round
 	/// and spawns main consensus tokio::tasks.
@@ -76,7 +76,7 @@ loop {
 			// Max Step Reached - happens only if no consensus is reached for up to 213 steps/71 iterations.
 		}
 	}
-	most_recent_block = winner;
+	tip = winner;
 
 	/// Internally, consensus instance may accept future messages for next round. 
 	/// They will be drained on running the round, that's why same consensus instance is used for all round executions.
diff --git a/consensus/src/aggregator.rs b/consensus/src/aggregator.rs
index f6f80e1af8..1db6b57c6b 100644
--- a/consensus/src/aggregator.rs
+++ b/consensus/src/aggregator.rs
@@ -234,8 +234,8 @@ mod tests {
         // Also populate a vector of headers
         let mut p = Provisioners::empty();
         let mut input = vec![];
-        let mut mrb_header = Header::default();
-        mrb_header.height = 0;
+        let mut tip_header = Header::default();
+        tip_header.height = 0;
 
         for secret_key in sks {
             let pubkey_bls = node_data::bls::PublicKey::new(
@@ -247,7 +247,7 @@ mod tests {
             let ru = RoundUpdate::new(
                 pubkey_bls,
                 secret_key,
-                &mrb_header,
+                &tip_header,
                 HashMap::new(),
             );
 
diff --git a/consensus/src/commons.rs b/consensus/src/commons.rs
index 3fe828e76f..07f2da4aed 100644
--- a/consensus/src/commons.rs
+++ b/consensus/src/commons.rs
@@ -42,17 +42,17 @@ impl RoundUpdate {
     pub fn new(
         pubkey_bls: PublicKey,
         secret_key: StakeSecretKey,
-        mrb_header: &Header,
+        tip_header: &Header,
         base_timeouts: TimeoutSet,
     ) -> Self {
-        let round = mrb_header.height + 1;
+        let round = tip_header.height + 1;
         RoundUpdate {
             round,
             pubkey_bls,
             secret_key,
-            cert: mrb_header.cert,
-            hash: mrb_header.hash,
-            seed: mrb_header.seed,
+            cert: tip_header.cert,
+            hash: tip_header.hash,
+            seed: tip_header.seed,
             base_timeouts,
         }
     }

From 52ae7e659f9054b64fbb7896aba9502fb314058d Mon Sep 17 00:00:00 2001
From: Federico Franzoni <8609060+fed-franz@users.noreply.github.com>
Date: Thu, 13 Jun 2024 16:18:15 +0200
Subject: [PATCH 2/7] node: Rename most_recent_block (mrb) to tip

---
 node/benches/accept.rs      |  18 +++----
 node/src/chain.rs           |  14 ++---
 node/src/chain/acceptor.rs  | 100 ++++++++++++++++++------------------
 node/src/chain/consensus.rs |  14 ++---
 4 files changed, 73 insertions(+), 73 deletions(-)

diff --git a/node/benches/accept.rs b/node/benches/accept.rs
index 698c3e7a67..fea46ec8dc 100644
--- a/node/benches/accept.rs
+++ b/node/benches/accept.rs
@@ -31,15 +31,15 @@ use rand::rngs::StdRng;
 use rand::SeedableRng;
 
 fn create_step_votes(
-    mrb_header: &ledger::Header,
+    tip_header: &ledger::Header,
     vote: &Vote,
     step: StepName,
     iteration: u8,
     provisioners: &Provisioners,
     keys: &[(node_data::bls::PublicKey, StakeSecretKey)],
 ) -> StepVotes {
-    let round = mrb_header.height + 1;
-    let seed = mrb_header.seed;
+    let round = tip_header.height + 1;
+    let seed = tip_header.seed;
 
     let generator = provisioners.get_generator(iteration, seed, round);
 
@@ -56,7 +56,7 @@ fn create_step_votes(
             let ru = RoundUpdate::new(
                 pk.clone(),
                 *sk,
-                mrb_header,
+                tip_header,
                 HashMap::default(),
             );
             let sig = match step {
@@ -118,7 +118,7 @@ pub fn verify_block_cert(c: &mut Criterion) {
                 keys.push((pk.clone(), sk));
                 provisioners.add_member_with_value(pk, 1000000000000)
             }
-            let mrb_header = ledger::Header {
+            let tip_header = ledger::Header {
                 seed: [5; 48].into(),
                 ..Default::default()
             };
@@ -127,7 +127,7 @@ pub fn verify_block_cert(c: &mut Criterion) {
             let iteration = 0;
 
             let validation = create_step_votes(
-                &mrb_header,
+                &tip_header,
                 &vote,
                 StepName::Validation,
                 iteration,
@@ -135,7 +135,7 @@ pub fn verify_block_cert(c: &mut Criterion) {
                 &keys[..],
             );
             let ratification = create_step_votes(
-                &mrb_header,
+                &tip_header,
                 &vote,
                 StepName::Ratification,
                 iteration,
@@ -157,9 +157,9 @@ pub fn verify_block_cert(c: &mut Criterion) {
                     b.to_async(FuturesExecutor).iter(|| async {
                         chain::verify_block_cert(
                             [0u8; 32],
-                            mrb_header.seed,
+                            tip_header.seed,
                             &provisioners,
-                            mrb_header.height + 1,
+                            tip_header.height + 1,
                             &cert,
                             iteration,
                         )
diff --git a/node/src/chain.rs b/node/src/chain.rs
index 825213517e..17b9c4222d 100644
--- a/node/src/chain.rs
+++ b/node/src/chain.rs
@@ -61,15 +61,15 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution>
         db: Arc<RwLock<DB>>,
         vm: Arc<RwLock<VM>>,
     ) -> anyhow::Result<()> {
-        let mrb = Self::load_most_recent_block(db.clone(), vm.clone()).await?;
+        let tip = Self::load_tip(db.clone(), vm.clone()).await?;
 
-        let state_hash = mrb.inner().header().state_hash;
+        let state_hash = tip.inner().header().state_hash;
         let provisioners_list = vm.read().await.get_provisioners(state_hash)?;
 
         // Initialize Acceptor
         let acc = Acceptor::init_consensus(
             &self.keys_path,
-            mrb,
+            tip,
             provisioners_list,
             db,
             network.clone(),
@@ -224,18 +224,18 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> ChainSrv<N, DB, VM> {
         }
     }
 
-    /// Load both most recent and last_finalized blocks from persisted ledger.
+    /// Load both the chain tip and last finalized block from persisted ledger.
     ///
     /// Panics
     ///
     /// If register entry is read but block is not found.
-    async fn load_most_recent_block(
+    async fn load_tip(
         db: Arc<RwLock<DB>>,
         vm: Arc<RwLock<VM>>,
     ) -> Result<BlockWithLabel> {
         let stored_block = db.read().await.update(|t| {
-            Ok(t.op_read(MD_HASH_KEY)?.and_then(|mrb_hash| {
-                t.fetch_block(&mrb_hash[..])
+            Ok(t.op_read(MD_HASH_KEY)?.and_then(|tip_hash| {
+                t.fetch_block(&tip_hash[..])
                     .expect("block to be found if metadata is set")
             }))
         })?;
diff --git a/node/src/chain/acceptor.rs b/node/src/chain/acceptor.rs
index 192fa90f0f..c2167db832 100644
--- a/node/src/chain/acceptor.rs
+++ b/node/src/chain/acceptor.rs
@@ -54,7 +54,7 @@ pub(crate) enum RevertTarget {
 /// Acceptor also manages the initialization and lifespan of Consensus task.
 pub(crate) struct Acceptor<N: Network, DB: database::DB, VM: vm::VMExecution> {
     /// Most recently accepted block a.k.a blockchain tip
-    mrb: RwLock<BlockWithLabel>,
+    tip: RwLock<BlockWithLabel>,
 
     /// Provisioners needed to verify next block
     pub(crate) provisioners_list: RwLock<ContextProvisioners>,
@@ -124,25 +124,25 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
     /// Finally it spawns a new consensus [`Task`]
     pub async fn init_consensus(
         keys_path: &str,
-        mrb: BlockWithLabel,
+        tip: BlockWithLabel,
         provisioners_list: Provisioners,
         db: Arc<RwLock<DB>>,
         network: Arc<RwLock<N>>,
         vm: Arc<RwLock<VM>>,
     ) -> anyhow::Result<Self> {
-        let mrb_height = mrb.inner().header().height;
-        let mrb_state_hash = mrb.inner().header().state_hash;
+        let tip_height = tip.inner().header().height;
+        let tip_state_hash = tip.inner().header().state_hash;
 
         let mut provisioners_list = ContextProvisioners::new(provisioners_list);
 
-        if mrb.inner().header().height > 0 {
+        if tip.inner().header().height > 0 {
             let changed_provisioners =
-                vm.read().await.get_changed_provisioners(mrb_state_hash)?;
+                vm.read().await.get_changed_provisioners(tip_state_hash)?;
             provisioners_list.apply_changes(changed_provisioners);
         }
 
         let acc = Self {
-            mrb: RwLock::new(mrb),
+            tip: RwLock::new(tip),
             provisioners_list: RwLock::new(provisioners_list),
             db: db.clone(),
             vm: vm.clone(),
@@ -160,7 +160,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
         );
 
         // Detect a consistency issue between VM and Ledger states.
-        if mrb_height > 0 && mrb_state_hash != state_root {
+        if tip_height > 0 && tip_state_hash != state_root {
             info!("revert to last finalized state");
             // Revert to last known finalized state.
             acc.try_revert(RevertTarget::LastFinalizedState).await?;
@@ -174,7 +174,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
         let base_timeouts = self.adjust_round_base_timeouts().await;
 
         self.task.write().await.spawn(
-            self.mrb.read().await.inner(),
+            self.tip.read().await.inner(),
             provisioners_list,
             &self.db,
             &self.vm,
@@ -331,19 +331,19 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
         Ok(change)
     }
 
-    /// Updates most_recent_block together with provisioners list.
+    /// Updates tip together with provisioners list.
     ///
     /// # Arguments
     ///
     /// * `blk` - Block that already exists in ledger
-    pub(crate) async fn update_most_recent_block(
+    pub(crate) async fn update_tip(
         &self,
         blk: &Block,
         label: Label,
     ) -> anyhow::Result<()> {
         let mut task = self.task.write().await;
 
-        let mut mrb = self.mrb.write().await;
+        let mut tip = self.tip.write().await;
         let mut provisioners_list = self.provisioners_list.write().await;
 
         // Ensure block that will be marked as blockchain tip does exist
@@ -374,7 +374,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
             vm.get_changed_provisioners(blk.header().state_hash)?;
         provisioners_list.apply_changes(changed_provisioners);
 
-        *mrb = BlockWithLabel::new_with_label(blk.clone(), label);
+        *tip = BlockWithLabel::new_with_label(blk.clone(), label);
 
         Ok(())
     }
@@ -403,16 +403,16 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
     ) -> anyhow::Result<Label> {
         let mut task = self.task.write().await;
 
-        let mut mrb = self.mrb.write().await;
+        let mut tip = self.tip.write().await;
         let mut provisioners_list = self.provisioners_list.write().await;
         let block_time =
-            blk.header().timestamp - mrb.inner().header().timestamp;
+            blk.header().timestamp - tip.inner().header().timestamp;
 
         let header_verification_start = std::time::Instant::now();
         // Verify Block Header
         let attested = verify_block_header(
             self.db.clone(),
-            &mrb.inner().header().clone(),
+            &tip.inner().header().clone(),
             &provisioners_list,
             blk.header(),
         )
@@ -426,7 +426,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
         let mut ffr = false;
 
         // Define new block label
-        let label = match (attested, mrb.is_final()) {
+        let label = match (attested, tip.is_final()) {
             (true, true) => Label::Final,
             (false, _) => Label::Accepted,
             (true, _) => {
@@ -482,7 +482,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
             self.log_missing_iterations(
                 provisioners_list.current(),
                 header.iteration,
-                mrb.inner().header().seed,
+                tip.inner().header().seed,
                 header.height,
             );
 
@@ -506,11 +506,11 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
                 provisioners_list.update_and_swap(new_prov)
             }
 
-            // Update most_recent_block
-            *mrb = blk;
+            // Update tip
+            *tip = blk;
 
-            if mrb.is_final() {
-                vm.finalize_state(mrb.inner().header().state_hash)?;
+            if tip.is_final() {
+                vm.finalize_state(tip.inner().header().state_hash)?;
             }
 
             anyhow::Ok(())
@@ -521,7 +521,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
         task.abort_with_wait().await;
 
         Self::emit_metrics(
-            mrb.inner(),
+            tip.inner(),
             &label,
             est_elapsed_time,
             block_time,
@@ -536,7 +536,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
             .await
             .update(|t| {
                 // Delete any candidate block older than TIP - OFFSET
-                let threshold = mrb
+                let threshold = tip
                     .inner()
                     .header()
                     .height
@@ -546,7 +546,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
 
                 // Delete from mempool any transaction already included in the
                 // block
-                for tx in mrb.inner().txs().iter() {
+                for tx in tip.inner().txs().iter() {
                     let _ = Mempool::delete_tx(t, tx.id())
                         .map_err(|e| warn!("Error while deleting tx: {e}"));
 
@@ -566,27 +566,27 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
 
         {
             // Avoid accumulation of future msgs while the node is syncing up
-            let round = mrb.inner().header().height;
+            let round = tip.inner().header().height;
             let mut f = task.future_msg.lock().await;
             f.remove_msgs_out_of_range(round + 1, OFFSET_FUTURE_MSGS);
             histogram!("dusk_future_msg_count").record(f.msg_count() as f64);
         }
 
-        let fsv_bitset = mrb.inner().header().cert.validation.bitset;
-        let ssv_bitset = mrb.inner().header().cert.ratification.bitset;
+        let fsv_bitset = tip.inner().header().cert.validation.bitset;
+        let ssv_bitset = tip.inner().header().cert.ratification.bitset;
 
         let duration = start.elapsed();
         info!(
             event = "block accepted",
-            height = mrb.inner().header().height,
-            iter = mrb.inner().header().iteration,
-            hash = to_str(&mrb.inner().header().hash),
-            txs = mrb.inner().txs().len(),
-            state_hash = to_str(&mrb.inner().header().state_hash),
+            height = tip.inner().header().height,
+            iter = tip.inner().header().iteration,
+            hash = to_str(&tip.inner().header().hash),
+            txs = tip.inner().txs().len(),
+            state_hash = to_str(&tip.inner().header().state_hash),
             fsv_bitset,
             ssv_bitset,
             block_time,
-            generator = mrb.inner().header().generator_bls_pubkey.to_bs58(),
+            generator = tip.inner().header().generator_bls_pubkey.to_bs58(),
             dur_ms = duration.as_millis(),
             label = format!("{:?}", label),
             ffr
@@ -596,7 +596,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
         if enable_consensus {
             let base_timeouts = self.adjust_round_base_timeouts().await;
             task.spawn(
-                mrb.inner(),
+                tip.inner(),
                 provisioners_list.clone(),
                 &self.db,
                 &self.vm,
@@ -645,7 +645,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
         // Delete any block until we reach the target_state_hash, the
         // VM was reverted to.
 
-        // The blockchain tip (most recent block) after reverting
+        // The blockchain tip after reverting
         let (blk, label) = self.db.read().await.update(|t| {
             let mut height = curr_height;
             while height != 0 {
@@ -698,26 +698,26 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
             state_root = hex::encode(blk.header().state_hash)
         );
 
-        self.update_most_recent_block(&blk, label).await
+        self.update_tip(&blk, label).await
     }
 
     /// Spawns consensus algorithm after aborting currently running one
     pub(crate) async fn restart_consensus(&mut self) {
         let mut task = self.task.write().await;
-        let mrb = self.mrb.read().await;
+        let tip = self.tip.read().await;
         let provisioners_list = self.provisioners_list.read().await.clone();
 
         task.abort_with_wait().await;
         info!(
             event = "restart consensus",
-            height = mrb.inner().header().height,
-            iter = mrb.inner().header().iteration,
-            hash = to_str(&mrb.inner().header().hash),
+            height = tip.inner().header().height,
+            iter = tip.inner().header().iteration,
+            hash = to_str(&tip.inner().header().hash),
         );
 
         let base_timeouts = self.adjust_round_base_timeouts().await;
         task.spawn(
-            mrb.inner(),
+            tip.inner(),
             provisioners_list,
             &self.db,
             &self.vm,
@@ -726,27 +726,27 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
     }
 
     pub(crate) async fn get_curr_height(&self) -> u64 {
-        self.mrb.read().await.inner().header().height
+        self.tip.read().await.inner().header().height
     }
 
     /// Returns chain tip header
     pub(crate) async fn tip_header(&self) -> ledger::Header {
-        self.mrb.read().await.inner().header().clone()
+        self.tip.read().await.inner().header().clone()
     }
 
     pub(crate) async fn get_curr_hash(&self) -> [u8; 32] {
-        self.mrb.read().await.inner().header().hash
+        self.tip.read().await.inner().header().hash
     }
 
     pub(crate) async fn get_latest_final_block(&self) -> Result<Block> {
-        let mrb = self.mrb.read().await;
-        if mrb.is_final() {
-            return Ok(mrb.inner().clone());
+        let tip = self.tip.read().await;
+        if tip.is_final() {
+            return Ok(tip.inner().clone());
         }
 
         // Retrieve the latest final block from the database
         let final_block = self.db.read().await.view(|v| {
-            let prev_height = mrb.inner().header().height - 1;
+            let prev_height = tip.inner().header().height - 1;
 
             for height in (0..prev_height).rev() {
                 if let Ok(Some(Label::Final)) =
@@ -769,7 +769,7 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
     }
 
     pub(crate) async fn get_curr_iteration(&self) -> u8 {
-        self.mrb.read().await.inner().header().iteration
+        self.tip.read().await.inner().header().iteration
     }
 
     pub(crate) async fn get_result_chan(
diff --git a/node/src/chain/consensus.rs b/node/src/chain/consensus.rs
index cebf551342..6ed32b3196 100644
--- a/node/src/chain/consensus.rs
+++ b/node/src/chain/consensus.rs
@@ -81,7 +81,7 @@ impl Task {
 
     pub(crate) fn spawn<D: database::DB, VM: vm::VMExecution>(
         &mut self,
-        most_recent_block: &node_data::ledger::Block,
+        tip: &node_data::ledger::Block,
         provisioners_list: ContextProvisioners,
         db: &Arc<RwLock<D>>,
         vm: &Arc<RwLock<VM>>,
@@ -95,7 +95,7 @@ impl Task {
             Arc::new(Mutex::new(Executor::new(
                 db,
                 vm,
-                most_recent_block.header().clone(),
+                tip.header().clone(),
                 provisioners_list, // TODO: Avoid cloning
             ))),
             Arc::new(Mutex::new(CandidateDB::new(db.clone()))),
@@ -104,7 +104,7 @@ impl Task {
         let ru = RoundUpdate::new(
             self.keys.1.clone(),
             self.keys.0,
-            most_recent_block.header(),
+            tip.header(),
             base_timeout.clone(),
         );
 
@@ -219,7 +219,7 @@ impl<DB: database::DB> dusk_consensus::commons::Database for CandidateDB<DB> {
 pub struct Executor<DB: database::DB, VM: vm::VMExecution> {
     db: Arc<RwLock<DB>>,
     vm: Arc<RwLock<VM>>,
-    mrb_header: ledger::Header,
+    tip_header: ledger::Header,
     provisioners: ContextProvisioners,
 }
 
@@ -227,13 +227,13 @@ impl<DB: database::DB, VM: vm::VMExecution> Executor<DB, VM> {
     fn new(
         db: &Arc<RwLock<DB>>,
         vm: &Arc<RwLock<VM>>,
-        mrb_header: ledger::Header,
+        tip_header: ledger::Header,
         provisioners: ContextProvisioners,
     ) -> Self {
         Executor {
             db: db.clone(),
             vm: vm.clone(),
-            mrb_header,
+            tip_header,
             provisioners,
         }
     }
@@ -248,7 +248,7 @@ impl<DB: database::DB, VM: vm::VMExecution> Operations for Executor<DB, VM> {
     ) -> Result<(), Error> {
         let validator = Validator::new(
             self.db.clone(),
-            &self.mrb_header,
+            &self.tip_header,
             &self.provisioners,
         );
 

From e52af1e2c6b7bd2e213fa64edafd0970c23ffd6c Mon Sep 17 00:00:00 2001
From: Federico Franzoni <8609060+fed-franz@users.noreply.github.com>
Date: Wed, 12 Jun 2024 11:43:20 +0200
Subject: [PATCH 3/7] consensus: Rename committee size to committee credits

---
 consensus/src/config.rs            | 10 +++---
 consensus/src/user/committee.rs    |  9 ++---
 consensus/src/user/provisioners.rs |  7 ++--
 consensus/src/user/sortition.rs    | 53 ++++++++++++++++--------------
 4 files changed, 43 insertions(+), 36 deletions(-)

diff --git a/consensus/src/config.rs b/consensus/src/config.rs
index 2e1909632e..ca17ff8e6b 100644
--- a/consensus/src/config.rs
+++ b/consensus/src/config.rs
@@ -16,12 +16,12 @@ pub const CONSENSUS_ROLLING_FINALITY_THRESHOLD: u64 = 20;
 pub const SUPERMAJORITY_THRESHOLD: f64 = 0.67;
 pub const MAJORITY_THRESHOLD: f64 = 0.5;
 
-/// Steps committee sizes
-pub const PROPOSAL_COMMITTEE_SIZE: usize = 1;
-pub const VALIDATION_COMMITTEE_SIZE: usize = 64;
-pub const RATIFICATION_COMMITTEE_SIZE: usize = 64;
+/// Total credits of steps committees
+pub const PROPOSAL_COMMITTEE_CREDITS: usize = 1;
+pub const VALIDATION_COMMITTEE_CREDITS: usize = 64;
+pub const RATIFICATION_COMMITTEE_CREDITS: usize = 64;
 
-/// Artifical delay on each Proposal step.
+/// Artificial delay on each Proposal step.
 pub const CONSENSUS_DELAY_MS: u64 = 1000;
 
 pub const DEFAULT_BLOCK_GAS_LIMIT: u64 = 5 * 1_000_000_000;
diff --git a/consensus/src/user/committee.rs b/consensus/src/user/committee.rs
index 54348b39e7..76befc70cd 100644
--- a/consensus/src/user/committee.rs
+++ b/consensus/src/user/committee.rs
@@ -36,12 +36,13 @@ impl Committee {
     pub fn new(provisioners: &Provisioners, cfg: &sortition::Config) -> Self {
         // Generate committee using deterministic sortition.
         let extracted = provisioners.create_committee(cfg);
-        let committe_size = cfg.committee_size() as f64;
+        let committee_credits = cfg.committee_credits() as f64;
 
-        let super_majority =
-            (committe_size * config::SUPERMAJORITY_THRESHOLD).ceil() as usize;
+        let super_majority = (committee_credits
+            * config::SUPERMAJORITY_THRESHOLD)
+            .ceil() as usize;
         let majority =
-            (committe_size * config::MAJORITY_THRESHOLD) as usize + 1;
+            (committee_credits * config::MAJORITY_THRESHOLD) as usize + 1;
 
         // Turn the raw vector into a hashmap where we map a pubkey to its
         // occurrences.
diff --git a/consensus/src/user/provisioners.rs b/consensus/src/user/provisioners.rs
index af43c43885..47b53ea6f0 100644
--- a/consensus/src/user/provisioners.rs
+++ b/consensus/src/user/provisioners.rs
@@ -164,8 +164,9 @@ impl Provisioners {
         &self,
         cfg: &sortition::Config,
     ) -> Vec<PublicKey> {
-        let committee_size = cfg.committee_size();
-        let mut extracted: Vec<PublicKey> = Vec::with_capacity(committee_size);
+        let committee_credits = cfg.committee_credits();
+        let mut extracted: Vec<PublicKey> =
+            Vec::with_capacity(committee_credits);
 
         let mut comm = CommitteeGenerator::from_provisioners(
             self,
@@ -175,7 +176,7 @@ impl Provisioners {
 
         let mut total_weight = comm.total_weight().into();
 
-        while extracted.len() != committee_size {
+        while extracted.len() != committee_credits {
             let counter = extracted.len() as u32;
 
             // 1. Compute n ← H(seed ∣∣ step ∣∣ counter)
diff --git a/consensus/src/user/sortition.rs b/consensus/src/user/sortition.rs
index 06e5be7161..3ffc7c6465 100644
--- a/consensus/src/user/sortition.rs
+++ b/consensus/src/user/sortition.rs
@@ -12,8 +12,8 @@ use sha3::{Digest, Sha3_256};
 use node_data::{bls::PublicKeyBytes, ledger::Seed, StepName};
 
 use crate::config::{
-    PROPOSAL_COMMITTEE_SIZE, RATIFICATION_COMMITTEE_SIZE,
-    VALIDATION_COMMITTEE_SIZE,
+    PROPOSAL_COMMITTEE_CREDITS, RATIFICATION_COMMITTEE_CREDITS,
+    VALIDATION_COMMITTEE_CREDITS,
 };
 
 #[derive(Debug, Clone, Default, Eq, Hash, PartialEq)]
@@ -21,7 +21,7 @@ pub struct Config {
     seed: Seed,
     round: u64,
     step: u16,
-    committee_size: usize,
+    committee_credits: usize,
     exclusion: Option<PublicKeyBytes>,
 }
 
@@ -33,23 +33,23 @@ impl Config {
         step: StepName,
         exclusion: Option<PublicKeyBytes>,
     ) -> Config {
-        let committee_size = match step {
-            StepName::Proposal => PROPOSAL_COMMITTEE_SIZE,
-            StepName::Ratification => RATIFICATION_COMMITTEE_SIZE,
-            StepName::Validation => VALIDATION_COMMITTEE_SIZE,
+        let committee_credits = match step {
+            StepName::Proposal => PROPOSAL_COMMITTEE_CREDITS,
+            StepName::Ratification => RATIFICATION_COMMITTEE_CREDITS,
+            StepName::Validation => VALIDATION_COMMITTEE_CREDITS,
         };
         let step = step.to_step(iteration);
         Self {
             seed,
             round,
             step,
-            committee_size,
+            committee_credits,
             exclusion,
         }
     }
 
-    pub fn committee_size(&self) -> usize {
-        self.committee_size
+    pub fn committee_credits(&self) -> usize {
+        self.committee_credits
     }
 
     pub fn step(&self) -> u16 {
@@ -109,14 +109,14 @@ mod tests {
             seed: Seed,
             round: u64,
             step: u16,
-            committee_size: usize,
+            committee_credits: usize,
             exclusion: Option<PublicKeyBytes>,
         ) -> Config {
             Self {
                 seed,
                 round,
                 step,
-                committee_size,
+                committee_credits,
                 exclusion,
             }
         }
@@ -163,16 +163,16 @@ mod tests {
     fn test_deterministic_sortition_1() {
         let p = generate_provisioners(5);
 
-        let committee_size = 64;
+        let committee_credits = 64;
 
         // Execute sortition with specific config
         let cfg = Config::raw(Seed::default(), 1, 1, 64, None);
 
         let committee = Committee::new(&p, &cfg);
 
-        // Verify expected committee size
+        // Verify expected committee credits
         assert_eq!(
-            committee_size,
+            committee_credits,
             committee.get_occurrences().iter().sum::<usize>()
         );
 
@@ -184,13 +184,18 @@ mod tests {
     fn test_deterministic_sortition_2() {
         let p = generate_provisioners(5);
 
-        let committee_size = 45;
-        let cfg =
-            Config::raw(Seed::from([3u8; 48]), 7777, 8, committee_size, None);
+        let committee_credits = 45;
+        let cfg = Config::raw(
+            Seed::from([3u8; 48]),
+            7777,
+            8,
+            committee_credits,
+            None,
+        );
 
         let committee = Committee::new(&p, &cfg);
         assert_eq!(
-            committee_size,
+            committee_credits,
             committee.get_occurrences().iter().sum::<usize>()
         );
         assert_eq!(vec![3, 17, 9, 16], committee.get_occurrences());
@@ -202,12 +207,12 @@ mod tests {
 
         let seed = Seed::from([3u8; 48]);
         let round = 7777;
-        let committee_size = 45;
+        let committee_credits = 45;
         let iteration = 2;
         let relative_step = 2;
         let step = iteration as u16 * 3 + relative_step;
 
-        let cfg = Config::raw(seed, round, step, committee_size, None);
+        let cfg = Config::raw(seed, round, step, committee_credits, None);
         let generator = p.get_generator(iteration, seed, round);
         let committee = Committee::new(&p, &cfg);
 
@@ -216,14 +221,14 @@ mod tests {
             .find(|&p| p.bytes() == &generator)
             .expect("Generator to be included");
         assert_eq!(
-            committee_size,
+            committee_credits,
             committee.get_occurrences().iter().sum::<usize>()
         );
         assert_eq!(vec![3, 17, 9, 16], committee.get_occurrences());
 
         // Run the same extraction, with the generator excluded
         let cfg =
-            Config::raw(seed, round, step, committee_size, Some(generator));
+            Config::raw(seed, round, step, committee_credits, Some(generator));
         let committee = Committee::new(&p, &cfg);
 
         assert!(
@@ -234,7 +239,7 @@ mod tests {
             "Generator to be excluded"
         );
         assert_eq!(
-            committee_size,
+            committee_credits,
             committee.get_occurrences().iter().sum::<usize>()
         );
         assert_eq!(vec![5, 23, 17], committee.get_occurrences());

From 2c2810f242eb54212f74b9fb320b68f4e789cdbf Mon Sep 17 00:00:00 2001
From: Federico Franzoni <8609060+fed-franz@users.noreply.github.com>
Date: Thu, 13 Jun 2024 16:21:21 +0200
Subject: [PATCH 4/7] node-data: Rename Certificate to Attestation

---
 node-data/src/encoding.rs | 34 +++++++++++++++++-----------------
 node-data/src/ledger.rs   | 36 ++++++++++++++++++------------------
 node-data/src/message.rs  | 20 ++++++++++----------
 3 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/node-data/src/encoding.rs b/node-data/src/encoding.rs
index 86acdc74ab..44858764eb 100644
--- a/node-data/src/encoding.rs
+++ b/node-data/src/encoding.rs
@@ -10,7 +10,7 @@ use execution_core::Transaction as PhoenixTransaction;
 
 use crate::bls::PublicKeyBytes;
 use crate::ledger::{
-    Block, Certificate, Header, IterationsInfo, Label, SpentTransaction,
+    Attestation, Block, Header, IterationsInfo, Label, SpentTransaction,
     StepVotes, Transaction,
 };
 use crate::message::payload::{
@@ -146,7 +146,7 @@ impl Serializable for SpentTransaction {
 impl Serializable for Header {
     fn write<W: Write>(&self, w: &mut W) -> io::Result<()> {
         self.marshal_hashable(w)?;
-        self.cert.write(w)?;
+        self.att.write(w)?;
         w.write_all(&self.hash)?;
 
         Ok(())
@@ -157,13 +157,13 @@ impl Serializable for Header {
         Self: Sized,
     {
         let mut header = Self::unmarshal_hashable(r)?;
-        header.cert = Certificate::read(r)?;
+        header.att = Attestation::read(r)?;
         header.hash = Self::read_bytes(r)?;
         Ok(header)
     }
 }
 
-impl Serializable for Certificate {
+impl Serializable for Attestation {
     fn write<W: Write>(&self, w: &mut W) -> io::Result<()> {
         self.result.write(w)?;
         self.validation.write(w)?;
@@ -180,7 +180,7 @@ impl Serializable for Certificate {
         let validation = StepVotes::read(r)?;
         let ratification = StepVotes::read(r)?;
 
-        Ok(Certificate {
+        Ok(Attestation {
             result,
             validation,
             ratification,
@@ -251,14 +251,14 @@ impl Serializable for RatificationResult {
 
 impl Serializable for IterationsInfo {
     fn write<W: Write>(&self, w: &mut W) -> io::Result<()> {
-        let count = self.cert_list.len() as u8;
+        let count = self.att_list.len() as u8;
         w.write_all(&count.to_le_bytes())?;
 
-        for iter in &self.cert_list {
+        for iter in &self.att_list {
             match iter {
-                Some((cert, pk)) => {
+                Some((att, pk)) => {
                     w.write_all(&[1])?;
-                    cert.write(w)?;
+                    att.write(w)?;
                     w.write_all(pk.inner())?;
                 }
                 None => w.write_all(&[0])?,
@@ -272,19 +272,19 @@ impl Serializable for IterationsInfo {
     where
         Self: Sized,
     {
-        let mut cert_list = vec![];
+        let mut att_list = vec![];
 
         let count = Self::read_u8(r)?;
 
         for _ in 0..count {
             let opt = Self::read_u8(r)?;
 
-            let cert = match opt {
+            let att = match opt {
                 0 => None,
                 1 => {
-                    let cert = Certificate::read(r)?;
+                    let att = Attestation::read(r)?;
                     let pk = Self::read_bytes(r)?;
-                    Some((cert, PublicKeyBytes(pk)))
+                    Some((att, PublicKeyBytes(pk)))
                 }
                 _ => {
                     return Err(io::Error::new(
@@ -293,10 +293,10 @@ impl Serializable for IterationsInfo {
                     ))
                 }
             };
-            cert_list.push(cert)
+            att_list.push(att)
         }
 
-        Ok(IterationsInfo { cert_list })
+        Ok(IterationsInfo { att_list })
     }
 }
 
@@ -433,8 +433,8 @@ mod tests {
     }
 
     #[test]
-    fn test_encoding_cert() {
-        assert_serializable::<Certificate>();
+    fn test_encoding_att() {
+        assert_serializable::<Attestation>();
     }
 
     #[test]
diff --git a/node-data/src/ledger.rs b/node-data/src/ledger.rs
index 2267cf4b54..0093672004 100644
--- a/node-data/src/ledger.rs
+++ b/node-data/src/ledger.rs
@@ -43,14 +43,14 @@ pub struct Header {
     pub txroot: Hash,
     pub gas_limit: u64,
     pub iteration: u8,
-    pub prev_block_cert: Certificate,
+    pub prev_block_cert: Attestation,
     pub failed_iterations: IterationsInfo,
 
     // Block hash
     pub hash: Hash,
 
     // Non-hashable fields
-    pub cert: Certificate,
+    pub att: Attestation,
 }
 
 impl std::fmt::Debug for Header {
@@ -70,7 +70,7 @@ impl std::fmt::Debug for Header {
             .field("gen_bls_pubkey", &to_str(self.generator_bls_pubkey.inner()))
             .field("gas_limit", &self.gas_limit)
             .field("hash", &to_str(&self.hash))
-            .field("cert", &self.cert)
+            .field("att", &self.att)
             .finish()
     }
 }
@@ -141,7 +141,7 @@ impl Transaction {
 
 #[derive(Debug, Clone, Copy, Default, Eq, PartialEq)]
 #[cfg_attr(any(feature = "faker", test), derive(Dummy))]
-pub struct Certificate {
+pub struct Attestation {
     pub result: RatificationResult,
     pub validation: StepVotes,
     pub ratification: StepVotes,
@@ -186,7 +186,7 @@ impl Header {
         let gas_limit = Self::read_u64_le(r)?;
         let iteration = Self::read_u8(r)?;
 
-        let prev_block_cert = Certificate::read(r)?;
+        let prev_block_cert = Attestation::read(r)?;
         let failed_iterations = IterationsInfo::read(r)?;
 
         Ok(Header {
@@ -202,7 +202,7 @@ impl Header {
             event_hash,
             txroot,
             hash: [0; 32],
-            cert: Default::default(),
+            att: Default::default(),
             prev_block_cert,
             failed_iterations,
         })
@@ -237,8 +237,8 @@ impl Block {
         &self.txs
     }
 
-    pub fn set_certificate(&mut self, cert: Certificate) {
-        self.header.cert = cert;
+    pub fn set_attestation(&mut self, att: Attestation) {
+        self.header.att = att;
     }
 }
 
@@ -356,22 +356,22 @@ impl PartialEq<Self> for SpentTransaction {
 
 impl Eq for SpentTransaction {}
 
-/// Includes a `NilQuorum` certificate and the key of the expected block
+/// Includes a failed attestation and the key of the expected block
 /// generator
-pub type IterationInfo = (Certificate, PublicKeyBytes);
+pub type IterationInfo = (Attestation, PublicKeyBytes);
 
-/// Defines a set of certificates of any former iterations
+/// Defines a set of attestations of any former iterations
 #[derive(Default, Eq, PartialEq, Clone)]
 pub struct IterationsInfo {
-    /// Represents a list of certificates where position is the iteration
+    /// Represents a list of attestations where position is the iteration
     /// number
-    pub cert_list: Vec<Option<IterationInfo>>,
+    pub att_list: Vec<Option<IterationInfo>>,
 }
 
 impl IterationsInfo {
-    pub fn new(certificates: Vec<Option<IterationInfo>>) -> Self {
+    pub fn new(attestations: Vec<Option<IterationInfo>>) -> Self {
         Self {
-            cert_list: certificates,
+            att_list: attestations,
         }
     }
 
@@ -387,7 +387,7 @@ impl IterationsInfo {
     pub fn to_missed_generators_bytes(
         &self,
     ) -> impl Iterator<Item = &PublicKeyBytes> {
-        self.cert_list
+        self.att_list
             .iter()
             .flatten()
             .filter(|(c, _)| {
@@ -479,14 +479,14 @@ pub mod faker {
 
     impl<T> Dummy<T> for IterationsInfo {
         fn dummy_with_rng<R: Rng + ?Sized>(_config: &T, rng: &mut R) -> Self {
-            let cert_list = vec![
+            let att_list = vec![
                 None,
                 Some(Faker.fake_with_rng(rng)),
                 None,
                 Some(Faker.fake_with_rng(rng)),
                 None,
             ];
-            IterationsInfo { cert_list }
+            IterationsInfo { att_list }
         }
     }
 
diff --git a/node-data/src/message.rs b/node-data/src/message.rs
index b46206859d..463ccb10b3 100644
--- a/node-data/src/message.rs
+++ b/node-data/src/message.rs
@@ -387,7 +387,7 @@ pub enum Payload {
 }
 
 pub mod payload {
-    use crate::ledger::{self, to_str, Block, Certificate, Hash, StepVotes};
+    use crate::ledger::{self, to_str, Attestation, Block, Hash, StepVotes};
     use crate::Serializable;
     use std::fmt;
     use std::io::{self, Read, Write};
@@ -663,13 +663,13 @@ pub mod payload {
     #[derive(Debug, Clone, Eq, PartialEq)]
     pub struct Quorum {
         pub header: ConsensusHeader,
-        pub cert: Certificate,
+        pub att: Attestation,
     }
 
     impl Serializable for Quorum {
         fn write<W: Write>(&self, w: &mut W) -> io::Result<()> {
             self.header.write(w)?;
-            self.cert.write(w)?;
+            self.att.write(w)?;
 
             Ok(())
         }
@@ -679,15 +679,15 @@ pub mod payload {
             Self: Sized,
         {
             let header = ConsensusHeader::read(r)?;
-            let cert = Certificate::read(r)?;
+            let att = Attestation::read(r)?;
 
-            Ok(Quorum { header, cert })
+            Ok(Quorum { header, att })
         }
     }
 
     impl Quorum {
         pub fn vote(&self) -> &Vote {
-            self.cert.result.vote()
+            self.att.result.vote()
         }
     }
 
@@ -758,7 +758,7 @@ pub mod payload {
         BlockFromHash,
         /// A full block fetched by block height
         BlockFromHeight,
-        /// A candidate block fetched by block hash, Cert is None
+        /// A candidate block fetched by block hash, Att is None
         CandidateFromHash,
     }
 
@@ -1338,13 +1338,13 @@ mod tests {
             event_hash: [5; 32],
             hash: [6; 32],
             txroot: [7; 32],
-            cert: Certificate {
+            att: Attestation {
                 validation: ledger::StepVotes::new([6; 48], 22222222),
                 ratification: ledger::StepVotes::new([7; 48], 3333333),
                 ..Default::default()
             },
             iteration: 1,
-            prev_block_cert: Certificate {
+            prev_block_cert: Attestation {
                 validation: ledger::StepVotes::new([6; 48], 444444444),
                 ratification: ledger::StepVotes::new([7; 48], 55555555),
                 ..Default::default()
@@ -1390,7 +1390,7 @@ mod tests {
 
         assert_serialize(payload::Quorum {
             header: consensus_header.clone(),
-            cert: Certificate {
+            att: Attestation {
                 result: payload::Vote::Valid([4; 32]).into(),
                 validation: ledger::StepVotes::new([1; 48], 12345),
                 ratification: ledger::StepVotes::new([2; 48], 98765),

From 7e7d8814b10881580faf285011765af1f10507e7 Mon Sep 17 00:00:00 2001
From: Federico Franzoni <8609060+fed-franz@users.noreply.github.com>
Date: Thu, 13 Jun 2024 16:20:41 +0200
Subject: [PATCH 5/7] consensus: Rename Certificate to Attestation

---
 consensus/src/commons.rs                  | 14 ++--
 consensus/src/consensus.rs                |  5 +-
 consensus/src/execution_ctx.rs            |  6 +-
 consensus/src/operations.rs               |  2 +-
 consensus/src/proposal/block_generator.rs |  6 +-
 consensus/src/proposal/step.rs            |  8 +--
 consensus/src/quorum/verifiers.rs         | 10 +--
 consensus/src/ratification/handler.rs     | 10 +--
 consensus/src/ratification/step.rs        |  2 +-
 consensus/src/step_votes_reg.rs           | 87 +++++++++++------------
 consensus/src/validation/handler.rs       |  6 +-
 consensus/src/validation/step.rs          |  4 +-
 12 files changed, 78 insertions(+), 82 deletions(-)

diff --git a/consensus/src/commons.rs b/consensus/src/commons.rs
index 07f2da4aed..0785bbb297 100644
--- a/consensus/src/commons.rs
+++ b/consensus/src/commons.rs
@@ -33,7 +33,7 @@ pub struct RoundUpdate {
 
     seed: Seed,
     hash: [u8; 32],
-    cert: Certificate,
+    att: Attestation,
 
     pub base_timeouts: TimeoutSet,
 }
@@ -50,7 +50,7 @@ impl RoundUpdate {
             round,
             pubkey_bls,
             secret_key,
-            cert: tip_header.cert,
+            att: tip_header.att,
             hash: tip_header.hash,
             seed: tip_header.seed,
             base_timeouts,
@@ -65,8 +65,8 @@ impl RoundUpdate {
         self.hash
     }
 
-    pub fn cert(&self) -> &Certificate {
-        &self.cert
+    pub fn att(&self) -> &Attestation {
+        &self.att
     }
 }
 
@@ -141,14 +141,14 @@ impl QuorumMsgSender {
     /// Sends an quorum (internally) to the lower layer.
     pub(crate) async fn send_quorum(&self, msg: Message) {
         match &msg.payload {
-            Payload::Quorum(q) if !q.cert.ratification.is_empty() => {
+            Payload::Quorum(q) if !q.att.ratification.is_empty() => {
                 tracing::debug!(
                     event = "send quorum_msg",
                     vote = ?q.vote(),
                     round = msg.header.round,
                     iteration = msg.header.iteration,
-                    validation = ?q.cert.validation,
-                    ratification = ?q.cert.ratification,
+                    validation = ?q.att.validation,
+                    ratification = ?q.att.ratification,
                 );
             }
             _ => return,
diff --git a/consensus/src/consensus.rs b/consensus/src/consensus.rs
index 7d8812bbea..f6c583cef0 100644
--- a/consensus/src/consensus.rs
+++ b/consensus/src/consensus.rs
@@ -19,8 +19,7 @@ use crate::{ratification, validation};
 use tracing::{debug, info, Instrument};
 
 use crate::iteration_ctx::IterationCtx;
-use crate::step_votes_reg::CertInfoRegistry;
-
+use crate::step_votes_reg::AttInfoRegistry;
 use std::env;
 use std::sync::Arc;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
@@ -141,7 +140,7 @@ impl<T: Operations + 'static, D: Database + 'static> Consensus<T, D> {
             }
 
             let sv_registry =
-                Arc::new(Mutex::new(CertInfoRegistry::new(ru.clone())));
+                Arc::new(Mutex::new(AttInfoRegistry::new(ru.clone())));
 
             let proposal_handler = Arc::new(Mutex::new(
                 proposal::handler::ProposalHandler::new(db.clone()),
diff --git a/consensus/src/execution_ctx.rs b/consensus/src/execution_ctx.rs
index 3a8f547227..e37632322a 100644
--- a/consensus/src/execution_ctx.rs
+++ b/consensus/src/execution_ctx.rs
@@ -10,7 +10,7 @@ use crate::iteration_ctx::IterationCtx;
 use crate::msg_handler::{HandleMsgOutput, MsgHandler};
 use crate::operations::Operations;
 use crate::queue::MsgRegistry;
-use crate::step_votes_reg::SafeCertificateInfoRegistry;
+use crate::step_votes_reg::SafeAttestationInfoRegistry;
 use crate::user::committee::Committee;
 use crate::user::provisioners::Provisioners;
 use crate::user::sortition;
@@ -52,7 +52,7 @@ pub struct ExecutionCtx<'a, DB: Database, T> {
 
     pub client: Arc<Mutex<T>>,
 
-    pub sv_registry: SafeCertificateInfoRegistry,
+    pub sv_registry: SafeAttestationInfoRegistry,
     quorum_sender: QuorumMsgSender,
 }
 
@@ -69,7 +69,7 @@ impl<'a, DB: Database, T: Operations + 'static> ExecutionCtx<'a, DB, T> {
         iteration: u8,
         step: StepName,
         client: Arc<Mutex<T>>,
-        sv_registry: SafeCertificateInfoRegistry,
+        sv_registry: SafeAttestationInfoRegistry,
         quorum_sender: QuorumMsgSender,
     ) -> Self {
         Self {
diff --git a/consensus/src/operations.rs b/consensus/src/operations.rs
index 698ae17a56..5fac23f7f2 100644
--- a/consensus/src/operations.rs
+++ b/consensus/src/operations.rs
@@ -57,7 +57,7 @@ pub trait Operations: Send + Sync {
     async fn verify_block_header(
         &self,
         candidate_header: &Header,
-        disable_winning_cert_check: bool,
+        disable_winning_att_check: bool,
     ) -> Result<(), Error>;
 
     async fn verify_state_transition(
diff --git a/consensus/src/proposal/block_generator.rs b/consensus/src/proposal/block_generator.rs
index b896eeae59..55aef2020c 100644
--- a/consensus/src/proposal/block_generator.rs
+++ b/consensus/src/proposal/block_generator.rs
@@ -6,7 +6,7 @@
 
 use crate::commons::{get_current_timestamp, RoundUpdate};
 use crate::operations::{CallParams, Operations};
-use node_data::ledger::{to_str, Block, Certificate, IterationsInfo, Seed};
+use node_data::ledger::{to_str, Attestation, Block, IterationsInfo, Seed};
 
 use crate::config;
 use crate::merkle::merkle_root;
@@ -117,8 +117,8 @@ impl<T: Operations> Generator<T> {
             state_hash: result.verification_output.state_root,
             event_hash: result.verification_output.event_hash,
             hash: [0; 32],
-            cert: Certificate::default(),
-            prev_block_cert: *ru.cert(),
+            att: Attestation::default(),
+            prev_block_cert: *ru.att(),
             txroot,
             iteration,
             failed_iterations,
diff --git a/consensus/src/proposal/step.rs b/consensus/src/proposal/step.rs
index aff0d19aae..02bd2805c8 100644
--- a/consensus/src/proposal/step.rs
+++ b/consensus/src/proposal/step.rs
@@ -59,16 +59,16 @@ impl<T: Operations + 'static, D: Database> ProposalStep<T, D> {
             let iteration =
                 cmp::min(config::RELAX_ITERATION_THRESHOLD, ctx.iteration);
 
-            // Fetch failed certificates from sv_registry
-            let failed_certificates =
-                ctx.sv_registry.lock().await.get_failed_certs(iteration);
+            // Fetch failed attestations from sv_registry
+            let failed_attestations =
+                ctx.sv_registry.lock().await.get_failed_atts(iteration);
 
             if let Ok(msg) = self
                 .bg
                 .generate_candidate_message(
                     &ctx.round_update,
                     ctx.iteration,
-                    IterationsInfo::new(failed_certificates),
+                    IterationsInfo::new(failed_attestations),
                 )
                 .await
             {
diff --git a/consensus/src/quorum/verifiers.rs b/consensus/src/quorum/verifiers.rs
index c180c3a045..5ca6a29acc 100644
--- a/consensus/src/quorum/verifiers.rs
+++ b/consensus/src/quorum/verifiers.rs
@@ -30,7 +30,7 @@ pub async fn verify_quorum(
     verify_step_votes(
         &quorum.header,
         quorum.vote(),
-        &quorum.cert.validation,
+        &quorum.att.validation,
         committees_set,
         seed,
         StepName::Validation,
@@ -39,7 +39,7 @@ pub async fn verify_quorum(
     .map_err(|e| {
         error!(
             desc = "invalid validation",
-            sv = ?quorum.cert.validation,
+            sv = ?quorum.att.validation,
             hdr = ?quorum.header,
         );
         e
@@ -49,7 +49,7 @@ pub async fn verify_quorum(
     verify_step_votes(
         &quorum.header,
         quorum.vote(),
-        &quorum.cert.ratification,
+        &quorum.att.ratification,
         committees_set,
         seed,
         StepName::Ratification,
@@ -58,7 +58,7 @@ pub async fn verify_quorum(
     .map_err(|e| {
         error!(
             desc = "invalid ratification",
-            sv = ?quorum.cert.ratification,
+            sv = ?quorum.att.ratification,
             hdr = ?quorum.header,
         );
         e
@@ -146,7 +146,7 @@ pub fn verify_votes(
     }
 
     // If bitset=0 this means that we are checking for failed iteration
-    // certificates. If a winning certificate is checked with bitset=0 it will
+    // attestations. If a winning attestation is checked with bitset=0 it will
     // fail to pass the quorum and results in VoteSetTooSmall.
     // FIXME: Anyway this should be handled properly, maybe with a different
     // function
diff --git a/consensus/src/ratification/handler.rs b/consensus/src/ratification/handler.rs
index 29e60baf88..4a5bce5d6b 100644
--- a/consensus/src/ratification/handler.rs
+++ b/consensus/src/ratification/handler.rs
@@ -6,9 +6,9 @@
 
 use crate::commons::{ConsensusError, RoundUpdate};
 use crate::msg_handler::{HandleMsgOutput, MsgHandler};
-use crate::step_votes_reg::SafeCertificateInfoRegistry;
+use crate::step_votes_reg::SafeAttestationInfoRegistry;
 use async_trait::async_trait;
-use node_data::ledger::Certificate;
+use node_data::ledger::Attestation;
 use node_data::{ledger, StepName};
 use tracing::{error, warn};
 
@@ -24,7 +24,7 @@ use node_data::message::{
 use crate::user::committee::Committee;
 
 pub struct RatificationHandler {
-    pub(crate) sv_registry: SafeCertificateInfoRegistry,
+    pub(crate) sv_registry: SafeAttestationInfoRegistry,
 
     pub(crate) aggregator: Aggregator,
     validation_result: ValidationResult,
@@ -172,7 +172,7 @@ impl MsgHandler for RatificationHandler {
 }
 
 impl RatificationHandler {
-    pub(crate) fn new(sv_registry: SafeCertificateInfoRegistry) -> Self {
+    pub(crate) fn new(sv_registry: SafeAttestationInfoRegistry) -> Self {
         Self {
             sv_registry,
             aggregator: Default::default(),
@@ -197,7 +197,7 @@ impl RatificationHandler {
 
         let quorum = payload::Quorum {
             header,
-            cert: Certificate {
+            att: Attestation {
                 result: vote.into(),
                 validation,
                 ratification,
diff --git a/consensus/src/ratification/step.rs b/consensus/src/ratification/step.rs
index 0795e80451..4d8fdb39fc 100644
--- a/consensus/src/ratification/step.rs
+++ b/consensus/src/ratification/step.rs
@@ -101,7 +101,7 @@ impl<T: Operations + 'static, DB: Database> RatificationStep<T, DB> {
         // There are these possible outputs:
         //  - Quorum on Valid Candidate
         //  - (unsupported) Quorum on Invalid Candidate
-        //  - Quorum on Timeout (NilQuorum)
+        //  - Quorum on Timeout
         //  - No Quorum (Validation step time-ed out)
         match msg.payload {
             Payload::ValidationResult(p) => handler.reset(iteration, *p),
diff --git a/consensus/src/step_votes_reg.rs b/consensus/src/step_votes_reg.rs
index 141b1a3136..69e3bb89a0 100644
--- a/consensus/src/step_votes_reg.rs
+++ b/consensus/src/step_votes_reg.rs
@@ -6,7 +6,7 @@
 
 use crate::commons::RoundUpdate;
 use node_data::bls::PublicKeyBytes;
-use node_data::ledger::{Certificate, IterationInfo, StepVotes};
+use node_data::ledger::{Attestation, IterationInfo, StepVotes};
 use node_data::message::payload::{RatificationResult, Vote};
 use node_data::message::{payload, Message};
 use node_data::StepName;
@@ -17,31 +17,31 @@ use tokio::sync::Mutex;
 use tracing::{debug, warn};
 
 #[derive(Clone)]
-struct CertificateInfo {
-    cert: Certificate,
+struct AttestationInfo {
+    att: Attestation,
 
     quorum_reached_validation: bool,
     quorum_reached_ratification: bool,
 }
 
-impl fmt::Display for CertificateInfo {
+impl fmt::Display for AttestationInfo {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
-            "cert_info: {:?}, validation: ({:?},{:?}), ratification: ({:?},{:?}) ",
-            self.cert.result,
-            self.cert.validation,
+            "att_info: {:?}, validation: ({:?},{:?}), ratification: ({:?},{:?}) ",
+            self.att.result,
+            self.att.validation,
             self.quorum_reached_validation,
-            self.cert.ratification,
+            self.att.ratification,
             self.quorum_reached_ratification
         )
     }
 }
 
-impl CertificateInfo {
+impl AttestationInfo {
     pub(crate) fn new(vote: Vote) -> Self {
-        CertificateInfo {
-            cert: Certificate {
+        AttestationInfo {
+            att: Attestation {
                 result: vote.into(),
                 ..Default::default()
             },
@@ -50,8 +50,8 @@ impl CertificateInfo {
         }
     }
 
-    /// Set certificate stepvotes according to [step]. Store [quorum_reached] to
-    /// calculate [CertificateInfo::is_ready]
+    /// Set attestation stepvotes according to [step]. Store [quorum_reached] to
+    /// calculate [AttestationInfo::is_ready]
     pub(crate) fn set_sv(
         &mut self,
         iter: u8,
@@ -61,14 +61,14 @@ impl CertificateInfo {
     ) {
         match step {
             StepName::Validation => {
-                self.cert.validation = sv;
+                self.att.validation = sv;
 
                 if quorum_reached {
                     self.quorum_reached_validation = quorum_reached;
                 }
             }
             StepName::Ratification => {
-                self.cert.ratification = sv;
+                self.att.ratification = sv;
 
                 if quorum_reached {
                     self.quorum_reached_ratification = quorum_reached;
@@ -98,7 +98,7 @@ impl CertificateInfo {
     /// ratification, except for NoQuorum votes where only the ratification
     /// quorum is checked
     fn is_ready(&self) -> bool {
-        match self.cert.result {
+        match self.att.result {
             RatificationResult::Fail(Vote::NoQuorum) => {
                 self.quorum_reached_ratification
             }
@@ -119,15 +119,15 @@ impl CertificateInfo {
     }
 }
 
-pub type SafeCertificateInfoRegistry = Arc<Mutex<CertInfoRegistry>>;
+pub type SafeAttestationInfoRegistry = Arc<Mutex<AttInfoRegistry>>;
 
 #[derive(Clone)]
-struct IterationCerts {
-    votes: HashMap<Vote, CertificateInfo>,
+struct IterationAtts {
+    votes: HashMap<Vote, AttestationInfo>,
     generator: PublicKeyBytes,
 }
 
-impl IterationCerts {
+impl IterationAtts {
     fn new(generator: PublicKeyBytes) -> Self {
         Self {
             votes: HashMap::new(),
@@ -135,32 +135,32 @@ impl IterationCerts {
         }
     }
 
-    fn failed(&self) -> Option<&CertificateInfo> {
+    fn failed(&self) -> Option<&AttestationInfo> {
         self.votes
             .values()
-            .find(|c| c.is_ready() && c.cert.result.failed())
+            .find(|c| c.is_ready() && c.att.result.failed())
     }
 
-    fn get_or_insert(&mut self, vote: &Vote) -> &mut CertificateInfo {
+    fn get_or_insert(&mut self, vote: &Vote) -> &mut AttestationInfo {
         if !self.votes.contains_key(vote) {
-            self.votes.insert(*vote, CertificateInfo::new(*vote));
+            self.votes.insert(*vote, AttestationInfo::new(*vote));
         }
         self.votes.get_mut(vote).expect("Vote to be inserted")
     }
 }
 
-pub struct CertInfoRegistry {
+pub struct AttInfoRegistry {
     ru: RoundUpdate,
 
-    /// Iterations certificates for current round keyed by iteration
-    cert_list: HashMap<u8, IterationCerts>,
+    /// Iterations attestations for current round keyed by iteration
+    att_list: HashMap<u8, IterationAtts>,
 }
 
-impl CertInfoRegistry {
+impl AttInfoRegistry {
     pub(crate) fn new(ru: RoundUpdate) -> Self {
         Self {
             ru,
-            cert_list: HashMap::new(),
+            att_list: HashMap::new(),
         }
     }
 
@@ -176,23 +176,23 @@ impl CertInfoRegistry {
         quorum_reached: bool,
         generator: &PublicKeyBytes,
     ) -> Option<Message> {
-        let cert = self
-            .cert_list
+        let att = self
+            .att_list
             .entry(iteration)
-            .or_insert_with(|| IterationCerts::new(*generator));
+            .or_insert_with(|| IterationAtts::new(*generator));
 
-        let cert_info = cert.get_or_insert(vote);
+        let att_info = att.get_or_insert(vote);
 
-        cert_info.set_sv(iteration, sv, step, quorum_reached);
-        cert_info.is_ready().then(|| {
-            Self::build_quorum_msg(&self.ru, iteration, cert_info.cert)
-        })
+        att_info.set_sv(iteration, sv, step, quorum_reached);
+        att_info
+            .is_ready()
+            .then(|| Self::build_quorum_msg(&self.ru, iteration, att_info.att))
     }
 
     fn build_quorum_msg(
         ru: &RoundUpdate,
         iteration: u8,
-        cert: Certificate,
+        att: Attestation,
     ) -> Message {
         let header = node_data::message::ConsensusHeader {
             prev_block_hash: ru.hash(),
@@ -200,26 +200,23 @@ impl CertInfoRegistry {
             iteration,
         };
 
-        let payload = payload::Quorum { header, cert };
+        let payload = payload::Quorum { header, att };
 
         Message::new_quorum(payload)
     }
 
-    pub(crate) fn get_failed_certs(
-        &self,
-        to: u8,
-    ) -> Vec<Option<IterationInfo>> {
+    pub(crate) fn get_failed_atts(&self, to: u8) -> Vec<Option<IterationInfo>> {
         let mut res = Vec::with_capacity(to as usize);
 
         for iteration in 0u8..to {
             res.push(
-                self.cert_list
+                self.att_list
                     .get(&iteration)
                     .and_then(|iter| {
                         iter.failed().map(|ci| (ci, iter.generator))
                     })
                     .filter(|(ci, _)| ci.is_ready())
-                    .map(|(ci, pk)| (ci.cert, pk)),
+                    .map(|(ci, pk)| (ci.att, pk)),
             );
         }
 
diff --git a/consensus/src/validation/handler.rs b/consensus/src/validation/handler.rs
index 75997012e2..9f00f03645 100644
--- a/consensus/src/validation/handler.rs
+++ b/consensus/src/validation/handler.rs
@@ -7,7 +7,7 @@
 use crate::aggregator::Aggregator;
 use crate::commons::{ConsensusError, RoundUpdate};
 use crate::msg_handler::{HandleMsgOutput, MsgHandler};
-use crate::step_votes_reg::SafeCertificateInfoRegistry;
+use crate::step_votes_reg::SafeAttestationInfoRegistry;
 use async_trait::async_trait;
 use node_data::ledger::{Block, StepVotes};
 use node_data::StepName;
@@ -33,12 +33,12 @@ fn final_result(
 pub struct ValidationHandler {
     pub(crate) aggr: Aggregator,
     pub(crate) candidate: Option<Block>,
-    sv_registry: SafeCertificateInfoRegistry,
+    sv_registry: SafeAttestationInfoRegistry,
     curr_iteration: u8,
 }
 
 impl ValidationHandler {
-    pub(crate) fn new(sv_registry: SafeCertificateInfoRegistry) -> Self {
+    pub(crate) fn new(sv_registry: SafeAttestationInfoRegistry) -> Self {
         Self {
             sv_registry,
             aggr: Aggregator::default(),
diff --git a/consensus/src/validation/step.rs b/consensus/src/validation/step.rs
index bd12d2cd89..ef0d98c681 100644
--- a/consensus/src/validation/step.rs
+++ b/consensus/src/validation/step.rs
@@ -79,8 +79,8 @@ impl<T: Operations + 'static> ValidationStep<T> {
         let candidate = candidate.expect("Candidate to be already checked");
         let header = candidate.header();
 
-        // Verify candidate header (all fields except the winning certificate)
-        // NB: Winning certificate is produced only on reaching consensus
+        // Verify candidate header (all fields except the winning attestation)
+        // NB: Winning attestation is produced only on reaching consensus
         if let Err(err) = executor
             .lock()
             .await

From 371a5ebefc5d0777d14fd12bdcfa06b92764308a Mon Sep 17 00:00:00 2001
From: Federico Franzoni <8609060+fed-franz@users.noreply.github.com>
Date: Thu, 13 Jun 2024 16:21:01 +0200
Subject: [PATCH 6/7] node: Rename Certificate to Attestation

---
 node/benches/accept.rs              | 16 ++++----
 node/src/chain.rs                   |  2 +-
 node/src/chain/acceptor.rs          | 10 ++---
 node/src/chain/consensus.rs         |  4 +-
 node/src/chain/fsm.rs               | 62 ++++++++++++++---------------
 node/src/chain/header_validation.rs | 56 +++++++++++++-------------
 6 files changed, 75 insertions(+), 75 deletions(-)

diff --git a/node/benches/accept.rs b/node/benches/accept.rs
index fea46ec8dc..10619f8282 100644
--- a/node/benches/accept.rs
+++ b/node/benches/accept.rs
@@ -22,7 +22,7 @@ use dusk_consensus::user::{
     sortition::Config as SortitionConfig,
 };
 use execution_core::{StakePublicKey, StakeSecretKey, StakeSignature};
-use node_data::ledger::{Certificate, StepVotes};
+use node_data::ledger::{Attestation, StepVotes};
 use node_data::message::payload::{
     QuorumType, RatificationResult, ValidationResult, Vote,
 };
@@ -104,8 +104,8 @@ where
     r
 }
 
-pub fn verify_block_cert(c: &mut Criterion) {
-    with_group("verify_block_cert", c, |group| {
+pub fn verify_block_att(c: &mut Criterion) {
+    with_group("verify_block_att", c, |group| {
         for input in INPUTS {
             group.measurement_time(Duration::from_secs(input.measurement_time));
             let mut keys = vec![];
@@ -142,7 +142,7 @@ pub fn verify_block_cert(c: &mut Criterion) {
                 &provisioners,
                 &keys[..],
             );
-            let cert = Certificate {
+            let att = Attestation {
                 result: RatificationResult::Success(Vote::Valid(block_hash)),
                 validation,
                 ratification,
@@ -150,17 +150,17 @@ pub fn verify_block_cert(c: &mut Criterion) {
 
             group.bench_function(
                 BenchmarkId::new(
-                    "verify_block_cert",
+                    "verify_block_att",
                     format!("{} prov", input.provisioners),
                 ),
                 move |b| {
                     b.to_async(FuturesExecutor).iter(|| async {
-                        chain::verify_block_cert(
+                        chain::verify_block_att(
                             [0u8; 32],
                             tip_header.seed,
                             &provisioners,
                             tip_header.height + 1,
-                            &cert,
+                            &att,
                             iteration,
                         )
                         .await
@@ -199,5 +199,5 @@ const INPUTS: &[Input] = &[
         measurement_time: 15,
     },
 ];
-criterion_group!(benches, verify_block_cert);
+criterion_group!(benches, verify_block_att);
 criterion_main!(benches);
diff --git a/node/src/chain.rs b/node/src/chain.rs
index 17b9c4222d..3f8f7973d9 100644
--- a/node/src/chain.rs
+++ b/node/src/chain.rs
@@ -22,7 +22,7 @@ use crate::{LongLivedService, Message};
 use anyhow::Result;
 use async_trait::async_trait;
 use dusk_consensus::commons::ConsensusError;
-pub use header_validation::verify_block_cert;
+pub use header_validation::verify_block_att;
 use node_data::ledger::{to_str, BlockWithLabel, Label};
 use node_data::message::AsyncQueue;
 use node_data::message::{Payload, Topics};
diff --git a/node/src/chain/acceptor.rs b/node/src/chain/acceptor.rs
index c2167db832..51a3e97a93 100644
--- a/node/src/chain/acceptor.rs
+++ b/node/src/chain/acceptor.rs
@@ -50,7 +50,7 @@ pub(crate) enum RevertTarget {
 }
 
 /// Implements block acceptance procedure. This includes block header,
-/// certificate and transactions full verifications.
+/// attestation and transactions full verifications.
 /// Acceptor also manages the initialization and lifespan of Consensus task.
 pub(crate) struct Acceptor<N: Network, DB: database::DB, VM: vm::VMExecution> {
     /// Most recently accepted block a.k.a blockchain tip
@@ -572,8 +572,8 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> Acceptor<N, DB, VM> {
             histogram!("dusk_future_msg_count").record(f.msg_count() as f64);
         }
 
-        let fsv_bitset = tip.inner().header().cert.validation.bitset;
-        let ssv_bitset = tip.inner().header().cert.ratification.bitset;
+        let fsv_bitset = tip.inner().header().att.validation.bitset;
+        let ssv_bitset = tip.inner().header().att.ratification.bitset;
 
         let duration = start.elapsed();
         info!(
@@ -867,8 +867,8 @@ async fn broadcast<N: Network>(network: &Arc<RwLock<N>>, msg: &Message) {
 /// Performs full verification of block header against prev_block header where
 /// prev_block is usually the blockchain tip
 ///
-/// Returns true if there is a cerificate for each failed iteration, and if
-/// that certificate has a quorum in the ratification phase.
+/// Returns true if there is a attestation for each failed iteration, and if
+/// that attestation has a quorum in the ratification phase.
 ///
 /// If there are no failed iterations, it returns true
 pub(crate) async fn verify_block_header<DB: database::DB>(
diff --git a/node/src/chain/consensus.rs b/node/src/chain/consensus.rs
index 6ed32b3196..2be034d377 100644
--- a/node/src/chain/consensus.rs
+++ b/node/src/chain/consensus.rs
@@ -244,7 +244,7 @@ impl<DB: database::DB, VM: vm::VMExecution> Operations for Executor<DB, VM> {
     async fn verify_block_header(
         &self,
         candidate_header: &Header,
-        disable_winning_cert_check: bool,
+        disable_winning_att_check: bool,
     ) -> Result<(), Error> {
         let validator = Validator::new(
             self.db.clone(),
@@ -253,7 +253,7 @@ impl<DB: database::DB, VM: vm::VMExecution> Operations for Executor<DB, VM> {
         );
 
         validator
-            .execute_checks(candidate_header, disable_winning_cert_check)
+            .execute_checks(candidate_header, disable_winning_att_check)
             .await
             .map_err(|err| {
                 error!("failed to verify header {}", err);
diff --git a/node/src/chain/fsm.rs b/node/src/chain/fsm.rs
index 4a61b621ee..3c92676873 100644
--- a/node/src/chain/fsm.rs
+++ b/node/src/chain/fsm.rs
@@ -11,7 +11,7 @@ use crate::{vm, Network};
 
 use crate::database::{Candidate, Ledger};
 use metrics::counter;
-use node_data::ledger::{to_str, Block, Certificate, Label};
+use node_data::ledger::{to_str, Attestation, Block, Label};
 use node_data::message::payload::{
     GetBlocks, GetResource, Inv, RatificationResult, Vote,
 };
@@ -29,7 +29,7 @@ use tracing::{debug, error, info, warn};
 
 const MAX_BLOCKS_TO_REQUEST: i16 = 50;
 const EXPIRY_TIMEOUT_MILLIS: i16 = 5000;
-const DEFAULT_CERT_CACHE_EXPIRY: Duration = Duration::from_secs(60);
+const DEFAULT_ATT_CACHE_EXPIRY: Duration = Duration::from_secs(60);
 
 /// Maximum number of hops between the requester and the node that contains the
 /// requested resource
@@ -79,8 +79,8 @@ pub(crate) struct SimpleFSM<N: Network, DB: database::DB, VM: vm::VMExecution> {
 
     blacklisted_blocks: SharedHashSet,
 
-    /// Certificates cached from received Quorum messages
-    certificates_cache: HashMap<[u8; 32], (Certificate, Instant)>,
+    /// Attestations cached from received Quorum messages
+    attestations_cache: HashMap<[u8; 32], (Attestation, Instant)>,
 }
 
 impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
@@ -99,7 +99,7 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
             acc,
             network,
             blacklisted_blocks,
-            certificates_cache: Default::default(),
+            attestations_cache: Default::default(),
         }
     }
 
@@ -137,7 +137,7 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
         }
 
         let now = Instant::now();
-        self.certificates_cache
+        self.attestations_cache
             .retain(|_, (_, expiry)| *expiry > now);
     }
 
@@ -173,7 +173,7 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
             return Ok(());
         }
 
-        if let Some(blk) = self.attach_cert_if_needed(blk).as_ref() {
+        if let Some(blk) = self.attach_att_if_needed(blk).as_ref() {
             match &mut self.curr {
                 State::InSync(ref mut curr) => {
                     if let Some((b, peer_addr)) =
@@ -212,25 +212,25 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
             }
         }
 
-        // Clean up certificate cache
+        // Clean up attestation cache
         let now = Instant::now();
-        self.certificates_cache
+        self.attestations_cache
             .retain(|_, (_, expiry)| *expiry > now);
-        self.certificates_cache.remove(&blk.header().hash);
+        self.attestations_cache.remove(&blk.header().hash);
 
         Ok(())
     }
 
-    async fn flood_request_block(&mut self, hash: [u8; 32], cert: Certificate) {
-        if self.certificates_cache.contains_key(&hash) {
+    async fn flood_request_block(&mut self, hash: [u8; 32], att: Attestation) {
+        if self.attestations_cache.contains_key(&hash) {
             return;
         }
 
-        // Save certificate in case only candidate block is received
+        // Save attestation in case only candidate block is received
         let expiry = Instant::now()
-            .checked_add(DEFAULT_CERT_CACHE_EXPIRY)
+            .checked_add(DEFAULT_ATT_CACHE_EXPIRY)
             .unwrap();
-        self.certificates_cache.insert(hash, (cert, expiry));
+        self.attestations_cache.insert(hash, (att, expiry));
 
         let mut inv = Inv::new(1);
         inv.add_candidate_from_hash(hash);
@@ -241,7 +241,7 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
     /// Handles a Quorum message that is received from either the network
     /// or internal consensus execution.
     ///
-    /// The winner block is built from the quorum certificate and candidate
+    /// The winner block is built from the quorum attestation and candidate
     /// block. If the candidate is not found in local storage then the
     /// block/candidate is requested from the network.
     pub(crate) async fn on_quorum_msg(
@@ -249,7 +249,7 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
         quorum: &payload::Quorum,
         msg: &Message,
     ) -> anyhow::Result<()> {
-        let res = match quorum.cert.result {
+        let res = match quorum.att.result {
             RatificationResult::Success(Vote::Valid(hash)) => {
                 let local_header = self.acc.read().await.tip_header().await;
                 let db = self.acc.read().await.db.clone();
@@ -263,7 +263,7 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
                         height = remote_height,
                     );
 
-                    self.flood_request_block(hash, quorum.cert).await;
+                    self.flood_request_block(hash, quorum.att).await;
 
                     Ok(None)
                 } else {
@@ -292,9 +292,9 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
                                 );
 
                                 // Candidate block is not found from local
-                                // storage.  Cache the certificate and request
+                                // storage.  Cache the attestation and request
                                 // candidate block only.
-                                self.flood_request_block(hash, quorum.cert)
+                                self.flood_request_block(hash, quorum.att)
                                     .await;
                                 Err(err)
                             }
@@ -315,7 +315,7 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
                 blk_hash = to_str(&block.header().hash),
             );
 
-            block.set_certificate(quorum.cert);
+            block.set_attestation(quorum.att);
             self.on_block_event(&block, msg.metadata.clone()).await?;
         }
 
@@ -356,23 +356,23 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
         Ok(())
     }
 
-    /// Try to attach the certificate to a block that misses it
-    fn attach_cert_if_needed<'a>(
+    /// Try to attach the attestation to a block that misses it
+    fn attach_att_if_needed<'a>(
         &self,
         blk: &'a Block,
     ) -> Option<Cow<'a, Block>> {
-        if blk.header().cert == Certificate::default() {
-            // The default cert means the block was retrieved from Candidate
-            // CF thus missing the certificate. If so, we try to set the valid
-            // certificate from the cache certificates.
-            if let Some((cert, _)) =
-                self.certificates_cache.get(&blk.header().hash)
+        if blk.header().att == Attestation::default() {
+            // The default att means the block was retrieved from Candidate
+            // CF thus missing the attestation. If so, we try to set the valid
+            // attestation from the cache attestations.
+            if let Some((att, _)) =
+                self.attestations_cache.get(&blk.header().hash)
             {
                 let mut blk = blk.clone();
-                blk.set_certificate(*cert);
+                blk.set_attestation(*att);
                 Some(Cow::Owned(blk))
             } else {
-                error!("cert not found for {}", hex::encode(blk.header().hash));
+                error!("att not found for {}", hex::encode(blk.header().hash));
                 None
             }
         } else {
diff --git a/node/src/chain/header_validation.rs b/node/src/chain/header_validation.rs
index b37e8e03df..fbdc60a7f6 100644
--- a/node/src/chain/header_validation.rs
+++ b/node/src/chain/header_validation.rs
@@ -50,29 +50,29 @@ impl<'a, DB: database::DB> Validator<'a, DB> {
 
     /// Executes check points to make sure a candidate header is fully valid
     ///
-    /// * `disable_winner_cert_check` - disables the check of the winning
-    /// certificate
+    /// * `disable_winner_att_check` - disables the check of the winning
+    /// attestation
     ///
-    /// Returns true if there is a certificate for each failed iteration, and if
-    /// that certificate has a quorum in the ratification phase.
+    /// Returns true if there is a attestation for each failed iteration, and if
+    /// that attestation has a quorum in the ratification phase.
     ///
     /// If there are no failed iterations, it returns true
     pub async fn execute_checks(
         &self,
         candidate_block: &'a ledger::Header,
-        disable_winner_cert_check: bool,
+        disable_winner_att_check: bool,
     ) -> anyhow::Result<bool> {
         self.verify_basic_fields(candidate_block).await?;
         self.verify_prev_block_cert(candidate_block).await?;
 
-        if !disable_winner_cert_check {
-            self.verify_winning_cert(candidate_block).await?;
+        if !disable_winner_att_check {
+            self.verify_winning_att(candidate_block).await?;
         }
 
         self.verify_failed_iterations(candidate_block).await
     }
 
-    /// Verifies any non-certificate field
+    /// Verifies any non-attestation field
     pub async fn verify_basic_fields(
         &self,
         candidate_block: &'a ledger::Header,
@@ -149,7 +149,7 @@ impl<'a, DB: database::DB> Validator<'a, DB> {
             Ok::<_, anyhow::Error>(prior_tip.header().seed)
         })?;
 
-        verify_block_cert(
+        verify_block_att(
             self.prev_header.prev_block_hash,
             prev_block_seed,
             self.provisioners.prev(),
@@ -162,8 +162,8 @@ impl<'a, DB: database::DB> Validator<'a, DB> {
         Ok(())
     }
 
-    /// Return true if there is a certificate for each failed iteration, and if
-    /// that certificate has a quorum in the ratification phase.
+    /// Return true if there is a attestation for each failed iteration, and if
+    /// that attestation has a quorum in the ratification phase.
     ///
     /// If there are no failed iterations, it returns true
     pub async fn verify_failed_iterations(
@@ -173,16 +173,16 @@ impl<'a, DB: database::DB> Validator<'a, DB> {
         // Verify Failed iterations
         let mut all_failed = true;
 
-        for (iter, cert) in candidate_block
+        for (iter, att) in candidate_block
             .failed_iterations
-            .cert_list
+            .att_list
             .iter()
             .enumerate()
         {
-            if let Some((cert, pk)) = cert {
-                info!(event = "verify_cert", cert_type = "failed_cert", iter);
+            if let Some((att, pk)) = att {
+                info!(event = "verify_att", att_type = "failed_att", iter);
 
-                if let RatificationResult::Success(_) = cert.result {
+                if let RatificationResult::Success(_) = att.result {
                     anyhow::bail!("Failed iterations should not contains a RatificationResult::Success");
                 }
 
@@ -194,12 +194,12 @@ impl<'a, DB: database::DB> Validator<'a, DB> {
 
                 anyhow::ensure!(pk == &expected_pk, "Invalid generator. Expected {expected_pk:?}, actual {pk:?}");
 
-                let quorums = verify_block_cert(
+                let quorums = verify_block_att(
                     self.prev_header.hash,
                     self.prev_header.seed,
                     self.provisioners.current(),
                     candidate_block.height,
-                    cert,
+                    att,
                     iter as u8,
                 )
                 .await?;
@@ -215,16 +215,16 @@ impl<'a, DB: database::DB> Validator<'a, DB> {
         Ok(all_failed)
     }
 
-    pub async fn verify_winning_cert(
+    pub async fn verify_winning_att(
         &self,
         candidate_block: &'a ledger::Header,
     ) -> anyhow::Result<()> {
-        verify_block_cert(
+        verify_block_att(
             self.prev_header.hash,
             self.prev_header.seed,
             self.provisioners.current(),
             candidate_block.height,
-            &candidate_block.cert,
+            &candidate_block.att,
             candidate_block.iteration,
         )
         .await?;
@@ -233,12 +233,12 @@ impl<'a, DB: database::DB> Validator<'a, DB> {
     }
 }
 
-pub async fn verify_block_cert(
+pub async fn verify_block_att(
     prev_block_hash: [u8; 32],
     curr_seed: Signature,
     curr_eligible_provisioners: &Provisioners,
     round: u64,
-    cert: &ledger::Certificate,
+    att: &ledger::Attestation,
     iteration: u8,
 ) -> anyhow::Result<(QuorumResult, QuorumResult)> {
     let committee = RwLock::new(CommitteeSet::new(curr_eligible_provisioners));
@@ -250,12 +250,12 @@ pub async fn verify_block_cert(
         round,
         prev_block_hash,
     };
-    let vote = cert.result.vote();
+    let vote = att.result.vote();
     // Verify validation
     match verifiers::verify_step_votes(
         &consensus_header,
         vote,
-        &cert.validation,
+        &att.validation,
         &committee,
         curr_seed,
         StepName::Validation,
@@ -272,7 +272,7 @@ pub async fn verify_block_cert(
                 round,
                 iteration,
                 to_str(curr_seed.inner()),
-                cert.validation,
+                att.validation,
                 e
             ));
         }
@@ -282,7 +282,7 @@ pub async fn verify_block_cert(
     match verifiers::verify_step_votes(
         &consensus_header,
         vote,
-        &cert.ratification,
+        &att.ratification,
         &committee,
         curr_seed,
         StepName::Ratification,
@@ -299,7 +299,7 @@ pub async fn verify_block_cert(
                 round,
                 iteration,
                 to_str(curr_seed.inner()),
-                cert.ratification,
+                att.ratification,
                 e,
             ));
         }

From 85fea81a6d0270ac534a121c085d50c62de4a460 Mon Sep 17 00:00:00 2001
From: Federico Franzoni <8609060+fed-franz@users.noreply.github.com>
Date: Thu, 13 Jun 2024 16:21:34 +0200
Subject: [PATCH 7/7] rusk: Rename Certificate to Attestation

---
 rusk/tests/common/state.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/rusk/tests/common/state.rs b/rusk/tests/common/state.rs
index b0771093ac..36a0c59940 100644
--- a/rusk/tests/common/state.rs
+++ b/rusk/tests/common/state.rs
@@ -17,7 +17,7 @@ use dusk_wallet_core::Transaction as PhoenixTransaction;
 use execution_core::StakePublicKey;
 use node_data::{
     bls::PublicKeyBytes,
-    ledger::{Block, Certificate, Header, IterationsInfo, SpentTransaction},
+    ledger::{Attestation, Block, Header, IterationsInfo, SpentTransaction},
     message::payload::Vote,
 };
 
@@ -86,8 +86,8 @@ pub fn generator_procedure(
 
     let mut failed_iterations = IterationsInfo::default();
     for to_slash in &missed_generators {
-        failed_iterations.cert_list.push(Some((
-            Certificate {
+        failed_iterations.att_list.push(Some((
+            Attestation {
                 result: node_data::message::payload::RatificationResult::Fail(
                     Vote::NoCandidate,
                 ),