chore: naming cleanup

bin/darkfid2/src/task/miner.rs

@@ -19,7 +19,7 @@
 use darkfi::{blockchain::BlockInfo, system::sleep, util::time::Timestamp, Result};
 use darkfi_sdk::{
     blockchain::{expected_reward, PidOutput, PreviousSlot, Slot},
-    pasta::{group::ff::Field, pallas},
+    pasta::pallas,
 };
 use log::info;
 use smol::channel::Receiver;
@@ -81,7 +81,14 @@ async fn miner_loop(node: &Darkfid, stop_signal: &Receiver<()>) -> Result<()> {
         let pid = PidOutput::default();
         let total_tokens = last_slot.total_tokens + last_slot.reward;
         let reward = expected_reward(id);
-        let slot = Slot::new(id, previous, pid, pallas::Base::ZERO, total_tokens, reward);
+        let slot = Slot::new(
+            id,
+            previous,
+            pid,
+            pallas::Base::from(last.header.nonce),
+            total_tokens,
+            reward,
+        );
 
         // Mine next block
         let mut next_block = BlockInfo::default();

src/contract/consensus/src/client/proposal_v1.rs

@@ -175,7 +175,7 @@ impl ConsensusProposalCallBuilder {
 
         info!("Building Consensus::ProposalV1 VRF proof");
         let mut vrf_input = Vec::with_capacity(32 + blake3::OUT_LEN + 32);
-        vrf_input.extend_from_slice(&self.slot.last_eta.to_repr());
+        vrf_input.extend_from_slice(&self.slot.last_nonce.to_repr());
         vrf_input.extend_from_slice(self.fork_previous_hash.as_bytes());
         vrf_input.extend_from_slice(&pallas::Base::from(self.slot.id).to_repr());
         let vrf_proof = VrfProof::prove(input.secret, &vrf_input, &mut OsRng);

src/contract/consensus/src/entrypoint/proposal_v1.rs

@@ -83,8 +83,6 @@ pub(crate) fn consensus_proposal_get_metadata_v1(
         return Err(ConsensusError::ProposalExtendsUnknownFork.into())
     }
 
-    // TODO: Add fork rank check using params.fork_hash
-
     // Verify sequence is correct
     if !slot.previous.second_to_last_hashes.contains(&params.fork_previous_hash) {
         let fork_prev = &params.fork_previous_hash;
@@ -94,13 +92,13 @@ pub(crate) fn consensus_proposal_get_metadata_v1(
 
     // Construct VRF input
     let mut vrf_input = Vec::with_capacity(32 + blake3::OUT_LEN + 32);
-    vrf_input.extend_from_slice(&slot.last_eta.to_repr());
+    vrf_input.extend_from_slice(&slot.last_nonce.to_repr());
     vrf_input.extend_from_slice(params.fork_previous_hash.as_bytes());
     vrf_input.extend_from_slice(&slot_fp.to_repr());
 
     // Verify VRF proof
     if !params.vrf_proof.verify(params.input.signature_public, &vrf_input) {
-        msg!("[ConsensusProposalV1] Error: eta VRF proof couldn't be verified");
+        msg!("[ConsensusProposalV1] Error: VRF proof couldn't be verified");
         return Err(ConsensusError::ProposalErroneousVrfProof.into())
     }
 

src/contract/test-harness/src/lib.rs

@@ -462,7 +462,7 @@ impl TestHarness {
         let genesis_slot = self.get_slot_by_slot(0).await?;
         let previous = PreviousSlot::new(0, vec![genesis_block], vec![genesis_block], 0.0);
         let pid = PidOutput::new(0.0, 0.0, genesis_slot.pid.sigma1, genesis_slot.pid.sigma2);
-        let slot = Slot::new(id, previous, pid, genesis_slot.last_eta, 0, 0);
+        let slot = Slot::new(id, previous, pid, genesis_slot.last_nonce, 0, 0);
 
         // Store generated slot
         for wallet in self.holders.values() {

src/sdk/src/blockchain.rs

@@ -90,8 +90,8 @@ pub struct Slot {
     pub previous: PreviousSlot,
     /// Slot PID output
     pub pid: PidOutput,
-    /// Last block/proposal eta
-    pub last_eta: pallas::Base,
+    /// Last block/proposal nonce(eta)
+    pub last_nonce: pallas::Base,
     /// Total tokens up until this slot
     pub total_tokens: u64,
     /// Slot reward
@@ -103,11 +103,11 @@ impl Slot {
         id: u64,
         previous: PreviousSlot,
         pid: PidOutput,
-        last_eta: pallas::Base,
+        last_nonce: pallas::Base,
         total_tokens: u64,
         reward: u64,
     ) -> Self {
-        Self { id, previous, pid, last_eta, total_tokens, reward }
+        Self { id, previous, pid, last_nonce, total_tokens, reward }
     }
 }
 

src/validator/consensus.rs

@@ -156,7 +156,7 @@ impl Consensus {
             time_keeper.slot_epoch(slot.id),
             slot.id,
             Timestamp::current_time(),
-            slot.last_eta,
+            slot.last_nonce,
         );
 
         // Generate the block
@@ -500,22 +500,24 @@ impl Fork {
         Proposal::new(block)
     }
 
-    /// Utility function to extract leader selection lottery randomness(eta),
+    /// Utility function to extract leader selection lottery randomness(nonce/eta),
     /// defined as the hash of the last block, converted to pallas base.
-    fn get_last_eta(&self) -> Result<pallas::Base> {
-        // Retrieve last block(or proposal) hash
-        let hash = if self.proposals.is_empty() {
-            self.overlay.lock().unwrap().last_block()?.hash()?
-        } else {
-            *self.proposals.last().unwrap()
-        };
-
-        // Read first 240 bits
-        let mut bytes: [u8; 32] = *hash.as_bytes();
-        bytes[30] = 0;
-        bytes[31] = 0;
-
-        Ok(pallas::Base::from_repr(bytes).unwrap())
+    fn get_last_nonce(&self) -> Result<pallas::Base> {
+        // Retrieve last block(or proposal)
+        let proposal = self.last_proposal()?;
+
+        match proposal.block.header.version {
+            1 => Ok(pallas::Base::from(proposal.block.header.nonce)),
+            2 => {
+                // Read first 240 bits of proposal hash
+                let mut bytes: [u8; 32] = *proposal.hash.as_bytes();
+                bytes[30] = 0;
+                bytes[31] = 0;
+
+                Ok(pallas::Base::from_repr(bytes).unwrap())
+            }
+            _ => Err(Error::BlockVersionIsInvalid(proposal.block.header.version)),
+        }
     }
 
     /// Auxiliary function to retrieve unproposed valid transactions.
@@ -586,11 +588,11 @@ impl Fork {
         let pid = PidOutput::new(f, error, sigma1, sigma2);
 
         // Each slot starts as an empty slot(not reward) when generated, carrying
-        // last eta
-        let last_eta = self.get_last_eta()?;
+        // last nonce(eta)
+        let last_nonce = self.get_last_nonce()?;
         let total_tokens = previous_slot.total_tokens + previous_slot.reward;
         let reward = 0;
-        let slot = Slot::new(id, previous, pid, last_eta, total_tokens, reward);
+        let slot = Slot::new(id, previous, pid, last_nonce, total_tokens, reward);
         self.slots.push(slot);
 
         Ok(())

src/validator/validation.rs

@@ -85,7 +85,7 @@ pub fn validate_pow_block(
     // Check block hash corresponds to next one (5)
     module.verify_block_hash(block)?;
 
-    // Verify slots vector is empty (6)
+    // Verify slots vector contains single slot (6)
     if block.slots.len() != 1 {
         return error
     }
@@ -100,6 +100,7 @@ pub fn validate_pow_block(
         previous_slot,
         &previous_hash,
         &previous.header.previous,
+        &pallas::Base::from(previous.header.nonce),
         expected_reward,
     )?;
 
@@ -120,7 +121,7 @@ pub fn validate_pow_block(
 ///     5. Slot previous error value correspond to previous slot one
 ///     6. Slot previous has only 1 producer(the miner)
 ///     7. PID output for this slot is correct(zero)
-///     8. Slot last eta is the expected one(zero)
+///     8. Slot last nonce is the expected one
 ///     9. Slot reward value is the expected one
 /// Additional validity rules can be applied.
 pub fn validate_pow_slot(
@@ -128,6 +129,7 @@ pub fn validate_pow_slot(
     previous: &Slot,
     previous_block_hash: &blake3::Hash,
     previous_block_sequence: &blake3::Hash,
+    last_nonce: &pallas::Base,
     expected_reward: u64,
 ) -> Result<()> {
     let error = Err(Error::SlotIsInvalid(slot.id));
@@ -169,8 +171,8 @@ pub fn validate_pow_slot(
         return error
     }
 
-    // Check eta is the expected one (8)
-    if slot.last_eta != pallas::Base::ZERO {
+    // Check nonce is the expected one
+    if &slot.last_nonce != last_nonce {
         return error
     }
 
@@ -270,7 +272,7 @@ pub fn validate_pos_block(
 ///        up until this slot
 ///     5. Slot previous error value correspond to previous slot one
 ///     6. PID output for this slot is correct
-///     7. Slot last eta is the expected one
+///     7. Slot last nonce(eta) is the expected one
 ///     8. Slot reward value is the expected one
 /// Additional validity rules can be applied.
 pub fn validate_pos_slot(
@@ -278,7 +280,7 @@ pub fn validate_pos_slot(
     previous: &Slot,
     previous_block_hash: &blake3::Hash,
     previous_block_sequence: &blake3::Hash,
-    last_eta: &pallas::Base,
+    last_nonce: &pallas::Base,
     expected_reward: u64,
 ) -> Result<()> {
     let error = Err(Error::SlotIsInvalid(slot.id));
@@ -315,8 +317,8 @@ pub fn validate_pos_slot(
         return error
     }
 
-    // Check eta is the expected one (7)
-    if &slot.last_eta != last_eta {
+    // Check nonce(eta) is the expected one (7)
+    if &slot.last_nonce != last_nonce {
         return error
     }
 

src/zkas/parser.rs

@@ -852,7 +852,7 @@ impl Parser {
             // Is there a valid use-case for defining nested arrays? For now,
             // if square brackets are present, raise an error unless there is
             // exactly one pair.
-            if left_bracket > 0 && left_bracket > 1 {
+            if left_bracket > 1 {
                 return Err(self.error.abort(
                     "Only one pair of brackets allowed for array declaration",
                     statement[0].line,