chore: more progress

Author: dpc

Cargo.lock

@@ -4,8 +4,10 @@ members = [
   "crates/bfte-node",
   "crates/consensus",
   "crates/consensus-core",
+  "crates/consensus-tests",
   "crates/util-array-type",
   "crates/util-db",
+  "crates/util-fmt-opt",
   "crates/util-error",
 ]
 resolver = "2"
@@ -27,10 +29,12 @@ collapsible_else_if = "allow"
 [workspace.dependencies]
 bfte = { path = "./crates/bfte" }
 bfte-consensus-core = { path = "./crates/consensus-core" }
+bfte-consensus-tests = { path = "./crates/consensus-tests" }
 bfte-consensus = { path = "./crates/consensus" }
 bfte-node = { path = "./crates/bfte-node" }
 bfte-util-array-type = { path = "./crates/util-array-type" }
 bfte-util-db = { path = "./crates/util-db" }
+bfte-util-fmt-opt = { path = "./crates/util-fmt-opt" }
 bfte-util-error = { path = "./crates/util-error" }
 
 anyhow = "1.0"
@@ -53,6 +57,7 @@ num-bigint = "0.4.6"
 serde_bytes = "0.11.17"
 serde = { version = "1.0", features = ["derive"] }
 snafu = { version = "0.8.5", features = ["rust_1_81"] }
+test-log = { version = "0.2.16", features = ["trace"] }
 tokio-test = "0.4.4"
 tokio = { version = "1.0", features = ["full"] }
 tracing = "0.1.41"

Cargo.toml

@@ -15,3 +15,4 @@ ed25519-dalek = { workspace = true }
 num-bigint = { workspace = true }
 serde_bytes = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
+snafu = { workspace = true }

crates/consensus-core/Cargo.toml

@@ -3,11 +3,15 @@ use std::sync::Arc;
 
 use bfte_util_array_type::{
     array_type_define, array_type_define_fixed_size, array_type_impl_base32_str,
-    array_type_impl_serde, array_type_impl_zero_default,
+    array_type_impl_debug_as_display, array_type_impl_serde, array_type_impl_zero_default,
 };
 use bincode::{Decode, Encode};
 use num_bigint::BigUint;
+use snafu::Snafu;
 
+use crate::bincode::STD_BINCODE_CONFIG;
+use crate::consensus_params::ConsensusParamsHash;
+use crate::federation_id::FederationId;
 use crate::num_peers::NumPeers;
 use crate::peer::PeerIdx;
 use crate::ver::ConsensusVersionMinor;
@@ -28,15 +32,6 @@ array_type_define_fixed_size! {
     pub struct BlockRound(u64);
 }
 
-// array_type_fixed_size_u64!(BlockSeq);
-// array_type_define! {
-//     /// Round the block was produced in
-//     #[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-//     pub struct BlockRound[8];
-// }
-
-// array_type_fixed_size_u64!(BlockRound);
-
 impl BlockRound {
     pub fn hash(self) -> blake3::Hash {
         blake3::hash(&self.0)
@@ -75,57 +70,127 @@ fn block_round_leader_test() {
     }
 }
 array_type_define! {
-    #[derive(Encode, Decode)]
+    #[derive(Encode, Decode, Copy, Clone)]
     pub struct BlockHash[32];
 }
 array_type_impl_zero_default!(BlockHash);
 array_type_impl_base32_str!(BlockHash);
 array_type_impl_serde!(BlockHash);
+array_type_impl_debug_as_display!(BlockHash);
 
-#[derive(Encode, Decode)]
+impl From<blake3::Hash> for BlockHash {
+    fn from(value: blake3::Hash) -> Self {
+        Self(*value.as_bytes())
+    }
+}
+
+impl From<BlockHash> for blake3::Hash {
+    fn from(value: BlockHash) -> Self {
+        blake3::Hash::from_bytes(value.0)
+    }
+}
+
+#[derive(Debug, Encode, Decode, Copy, Clone, PartialEq, Eq)]
 pub struct BlockHeader {
-    pub consensus_minor_version: ConsensusVersionMinor,
-    pub seq: BlockSeq,
-    pub round: BlockRound,
-    pub prev_block_id: BlockHash,
-    pub payload_hash: BlockPayloadHash,
+    pub seq: BlockSeq,     // 8B
+    pub round: BlockRound, // 8B
+    /// Commits to previous non-dummy `BlockHeader`
+    pub prev_block_hash: BlockHash, // 32B
+    /// Commits to [`ConsensusParams`] used for this block
+    pub consensus_params_hash: ConsensusParamsHash, // 32B
+    /// Commits to [`BlockPayload`]
+    pub payload_hash: BlockPayloadHash, // 32B
+}
+
+#[test]
+fn block_header_size_sanity() {
+    let block = BlockHeader::dummy(0.into(), 0.into());
+    assert_eq!(
+        bincode::encode_to_vec(block, STD_BINCODE_CONFIG)
+            .expect("Can't fail")
+            .len(),
+        112
+    )
 }
 
+#[derive(Debug, Snafu)]
+pub struct PayloadHashMismatchError;
+
+pub type PayloadHashMismatchResult<T> = std::result::Result<T, PayloadHashMismatchError>;
+
 impl BlockHeader {
-    pub fn dummy(round: BlockRound, consensus_minor_version: ConsensusVersionMinor) -> Self {
+    pub fn hash(&self) -> BlockHash {
+        // TODO: use static array for encoding output
+        blake3::hash(&bincode::encode_to_vec(self, STD_BINCODE_CONFIG).expect("Can't fail")).into()
+    }
+
+    pub fn verify_payload(&self, payload: &BlockPayload) -> PayloadHashMismatchResult<()> {
+        if payload.hash() != self.payload_hash {
+            return Err(PayloadHashMismatchError);
+        }
+
+        Ok(())
+    }
+    pub fn dummy(round: BlockRound, consensus_params_hash: ConsensusParamsHash) -> Self {
         Self {
             seq: BlockSeq::default(),
             round,
-            prev_block_id: BlockHash::ZERO,
+            prev_block_hash: BlockHash::ZERO,
+            consensus_params_hash,
             payload_hash: BlockPayloadHash::ZERO,
-            consensus_minor_version,
         }
     }
 
     pub fn is_dummy(&self) -> bool {
         self.seq == BlockSeq::ZERO
-            && self.prev_block_id == BlockHash::ZERO
+            && self.prev_block_hash == BlockHash::ZERO
             && self.payload_hash == BlockPayloadHash::ZERO
     }
 
     pub fn sign_by(&self, _secret_key: ed25519_dalek::SecretKey) {
         todo!()
     }
+
+    pub fn does_extend(
+        &self,
+        prev_block: Option<BlockHeader>,
+        consensus_params_hash: ConsensusParamsHash,
+    ) -> bool {
+        if self.consensus_params_hash.to_bytes() != consensus_params_hash.to_bytes() {
+            return false;
+        }
+
+        if let Some(prev_block) = prev_block {
+            prev_block.seq.next() == Some(self.seq)
+                && prev_block.round < self.round
+                && prev_block.hash() == self.prev_block_hash
+        } else {
+            // Note: 0 round block could be a dummy, so we can't require round to be 0
+            self.seq == BlockSeq::ZERO && self.prev_block_hash == BlockHash::ZERO
+        }
+    }
 }
+
 #[derive(Encode, Decode)]
 pub struct SignedBlock {
     block: BlockHeader,
     signatures: BTreeMap<PeerIdx, BlockSignature>,
 }
 
 array_type_define! {
-    #[derive(Encode, Decode)]
+    #[derive(Encode, Decode, Copy, Clone)]
     pub struct BlockPayloadHash[32];
 }
 array_type_impl_zero_default!(BlockPayloadHash);
 array_type_impl_base32_str!(BlockPayloadHash);
 array_type_impl_serde!(BlockPayloadHash);
+array_type_impl_debug_as_display!(BlockPayloadHash);
 
+impl From<blake3::Hash> for BlockPayloadHash {
+    fn from(value: blake3::Hash) -> Self {
+        Self(*value.as_bytes())
+    }
+}
 array_type_define! {
     #[derive(Encode, Decode)]
     pub struct BlockSignature[32];
@@ -135,4 +200,10 @@ array_type_impl_base32_str!(BlockSignature);
 array_type_impl_serde!(BlockSignature);
 
 #[derive(Encode, Decode, Clone)]
-pub struct BlockPayload(Arc<u8>);
+pub struct BlockPayload(Arc<[u8]>);
+
+impl BlockPayload {
+    pub fn hash(&self) -> BlockPayloadHash {
+        blake3::hash(&self.0).into()
+    }
+}

crates/consensus-core/src/block.rs

@@ -0,0 +1,48 @@
+use bfte_util_array_type::{
+    array_type_define, array_type_impl_base32_str, array_type_impl_debug_as_display,
+    array_type_impl_serde, array_type_impl_zero_default,
+};
+use bincode::{Decode, Encode};
+
+use crate::bincode::STD_BINCODE_CONFIG;
+use crate::block::BlockRound;
+use crate::num_peers::{NumPeers, ToNumPeers as _};
+use crate::peer::{PeerIdx, PeerPubkey};
+use crate::ver::ConsensusVersion;
+
+/// Global consensus parameters
+#[derive(Decode, Encode, Clone, PartialEq, Eq)]
+pub struct ConsensusParams {
+    pub version: ConsensusVersion,
+    pub peers: Vec<PeerPubkey>,
+}
+
+impl ConsensusParams {
+    pub fn num_peers(&self) -> NumPeers {
+        self.peers.to_num_peers()
+    }
+
+    pub fn leader_idx(&self, round: BlockRound) -> PeerIdx {
+        round.leader_idx(self.num_peers())
+    }
+
+    pub fn hash(&self) -> ConsensusParamsHash {
+        blake3::hash(&bincode::encode_to_vec(self, STD_BINCODE_CONFIG).expect("Can't fail")).into()
+    }
+}
+
+array_type_define! {
+    #[derive(Encode, Decode, Copy, Clone)]
+    pub struct ConsensusParamsHash[32];
+}
+
+array_type_impl_zero_default!(ConsensusParamsHash);
+array_type_impl_base32_str!(ConsensusParamsHash);
+array_type_impl_serde!(ConsensusParamsHash);
+array_type_impl_debug_as_display!(ConsensusParamsHash);
+
+impl From<blake3::Hash> for ConsensusParamsHash {
+    fn from(value: blake3::Hash) -> Self {
+        Self(*value.as_bytes())
+    }
+}

crates/consensus-core/src/consensus_params.rs

@@ -0,0 +1,26 @@
+use bfte_util_array_type::{
+    array_type_define, array_type_impl_base32_str, array_type_impl_debug_as_display,
+    array_type_impl_serde, array_type_impl_zero_default,
+};
+use bincode::{Decode, Encode};
+
+array_type_define! {
+    #[derive(Encode, Decode, Copy, Clone)]
+    pub struct FederationId[32];
+}
+array_type_impl_zero_default!(FederationId);
+array_type_impl_base32_str!(FederationId);
+array_type_impl_serde!(FederationId);
+array_type_impl_debug_as_display!(FederationId);
+
+impl From<blake3::Hash> for FederationId {
+    fn from(value: blake3::Hash) -> Self {
+        Self(*value.as_bytes())
+    }
+}
+
+impl From<FederationId> for blake3::Hash {
+    fn from(value: FederationId) -> Self {
+        blake3::Hash::from_bytes(value.0)
+    }
+}

crates/consensus-core/src/federation_id.rs

@@ -2,27 +2,33 @@
 
 use ::bincode::{Decode, Encode};
 use bfte_util_array_type::{
-    array_type_define, array_type_impl_base32_str, array_type_impl_serde,
-    array_type_impl_zero_default,
+    array_type_define, array_type_impl_base32_str, array_type_impl_debug_as_display,
+    array_type_impl_serde, array_type_impl_zero_default,
 };
-use peer::PeerIdx;
 
 pub mod bincode;
 pub mod block;
 pub mod citem;
+pub mod consensus_params;
+pub mod federation_id;
+pub mod msg;
 pub mod num_peers;
 pub mod peer;
+pub mod signed;
 pub mod ver;
+pub mod vote;
 
 array_type_define! {
-    #[derive(Encode, Decode)]
-    pub struct Signature[32];
+    #[derive(Encode, Decode, Copy, Clone)]
+    pub struct Signature[64];
 }
 array_type_impl_zero_default!(Signature);
 array_type_impl_base32_str!(Signature);
 array_type_impl_serde!(Signature);
+array_type_impl_debug_as_display!(Signature);
 
-pub struct PeerSignature {
-    pub peer_idx: PeerIdx,
-    pub signature: Signature,
+impl From<Signature> for ed25519_dalek::Signature {
+    fn from(value: Signature) -> Self {
+        ed25519_dalek::Signature::from_bytes(&value.0)
+    }
 }