chain: rename BlockHeader to block::Header

zebra-chain/src/block.rs

@@ -12,7 +12,7 @@ pub mod merkle;
 mod tests;
 
 pub use hash::Hash;
-pub use header::BlockHeader;
+pub use header::Header;
 pub use height::Height;
 pub use root_hash::RootHash;
 
@@ -38,7 +38,7 @@ use proptest_derive::Arbitrary;
 #[cfg_attr(test, derive(Arbitrary))]
 pub struct Block {
     /// The block header, containing block metadata.
-    pub header: BlockHeader,
+    pub header: Header,
     /// The block transactions.
     pub transactions: Vec<std::sync::Arc<Transaction>>,
 }

zebra-chain/src/block/hash.rs

@@ -8,7 +8,7 @@ use crate::serialization::{
     sha256d, ReadZcashExt, SerializationError, ZcashDeserialize, ZcashSerialize,
 };
 
-use super::BlockHeader;
+use super::Header;
 
 /// A SHA-256d hash of a BlockHeader.
 ///
@@ -34,8 +34,8 @@ impl fmt::Debug for Hash {
     }
 }
 
-impl<'a> From<&'a BlockHeader> for Hash {
-    fn from(block_header: &'a BlockHeader) -> Self {
+impl<'a> From<&'a Header> for Hash {
+    fn from(block_header: &'a Header) -> Self {
         let mut hash_writer = sha256d::Writer::default();
         block_header
             .zcash_serialize(&mut hash_writer)

zebra-chain/src/block/header.rs

@@ -12,7 +12,7 @@ use super::{merkle::MerkleTreeRootHash, Error, Hash};
 /// header. Each block points backwards to its parent, all the way
 /// back to the genesis block (the first block in the blockchain).
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
-pub struct BlockHeader {
+pub struct Header {
     /// The block's version field. This is supposed to be `4`:
     ///
     /// > The current and only defined block version number for Zcash is 4.
@@ -66,7 +66,7 @@ pub struct BlockHeader {
     pub solution: Solution,
 }
 
-impl BlockHeader {
+impl Header {
     /// Returns true if the header is valid based on its `EquihashSolution`
     pub fn is_equihash_solution_valid(&self) -> Result<(), EquihashError> {
         let n = 200;

zebra-chain/src/block/serialize.rs

@@ -8,8 +8,8 @@ use crate::work::{difficulty::CompactDifficulty, equihash};
 
 use super::merkle::MerkleTreeRootHash;
 use super::Block;
-use super::BlockHeader;
 use super::Hash;
+use super::Header;
 
 /// The maximum size of a Zcash block, in bytes.
 ///
@@ -19,7 +19,7 @@ use super::Hash;
 /// transaction in the chain is approximately 1.5 kB smaller.)
 pub const MAX_BLOCK_BYTES: u64 = 2_000_000;
 
-impl ZcashSerialize for BlockHeader {
+impl ZcashSerialize for Header {
     fn zcash_serialize<W: io::Write>(&self, mut writer: W) -> Result<(), io::Error> {
         writer.write_u32::<LittleEndian>(self.version)?;
         self.previous_block_hash.zcash_serialize(&mut writer)?;
@@ -36,7 +36,7 @@ impl ZcashSerialize for BlockHeader {
     }
 }
 
-impl ZcashDeserialize for BlockHeader {
+impl ZcashDeserialize for Header {
     fn zcash_deserialize<R: io::Read>(mut reader: R) -> Result<Self, SerializationError> {
         // The Zcash specification says that
         // "The current and only defined block version number for Zcash is 4."
@@ -68,7 +68,7 @@ impl ZcashDeserialize for BlockHeader {
             return Err(SerializationError::Parse("version must be at least 4"));
         }
 
-        Ok(BlockHeader {
+        Ok(Header {
             version,
             previous_block_hash: Hash::zcash_deserialize(&mut reader)?,
             merkle_root_hash: MerkleTreeRootHash(reader.read_32_bytes()?),

zebra-chain/src/block/tests/arbitrary.rs

@@ -23,7 +23,7 @@ impl Arbitrary for RootHash {
     type Strategy = BoxedStrategy<Self>;
 }
 
-impl Arbitrary for BlockHeader {
+impl Arbitrary for Header {
     type Parameters = ();
 
     fn arbitrary_with(_args: ()) -> Self::Strategy {
@@ -49,7 +49,7 @@ impl Arbitrary for BlockHeader {
                     difficulty_threshold,
                     nonce,
                     solution,
-                )| BlockHeader {
+                )| Header {
                     version,
                     previous_block_hash,
                     merkle_root_hash,

zebra-chain/src/block/tests/generate.rs

@@ -7,11 +7,11 @@ use crate::{
     transaction::{LockTime, Transaction, TransparentInput, TransparentOutput},
 };
 
-use super::super::{serialize::MAX_BLOCK_BYTES, Block, BlockHeader};
+use super::super::{serialize::MAX_BLOCK_BYTES, Block, Header};
 
 /// Generate a block header
-pub fn block_header() -> BlockHeader {
-    BlockHeader::zcash_deserialize(&zebra_test::vectors::DUMMY_HEADER[..]).unwrap()
+pub fn block_header() -> Header {
+    Header::zcash_deserialize(&zebra_test::vectors::DUMMY_HEADER[..]).unwrap()
 }
 
 /// Generate a block with multiple transactions just below limit

zebra-chain/src/block/tests/prop.rs

@@ -18,7 +18,7 @@ proptest! {
     }
 
     #[test]
-    fn blockheader_roundtrip(header in any::<BlockHeader>()) {
+    fn blockheader_roundtrip(header in any::<Header>()) {
         let bytes = header.zcash_serialize_to_vec()?;
         let other_header = bytes.zcash_deserialize_into()?;
 

zebra-chain/src/block/tests/vectors.rs

@@ -54,7 +54,7 @@ fn blockheaderhash_from_blockheader() {
 fn deserialize_blockheader() {
     // https://explorer.zcha.in/blocks/415000
     let _header = zebra_test::vectors::HEADER_MAINNET_415000_BYTES
-        .zcash_deserialize_into::<BlockHeader>()
+        .zcash_deserialize_into::<Header>()
         .expect("blockheader test vector should deserialize");
 }
 

zebra-chain/src/work/tests/prop.rs

@@ -1,6 +1,6 @@
 use proptest::prelude::*;
 
-use crate::block::{Block, BlockHeader};
+use crate::block::{self, Block};
 use crate::serialization::{ZcashDeserialize, ZcashDeserializeInto, ZcashSerialize};
 
 use super::super::*;
@@ -20,12 +20,12 @@ fn equihash_solution_roundtrip() {
 }
 
 prop_compose! {
-    fn randomized_solutions(real_header: BlockHeader)
+    fn randomized_solutions(real_header: block::Header)
         (fake_solution in any::<equihash::Solution>()
             .prop_filter("solution must not be the actual solution", move |s| {
                 s != &real_header.solution
             })
-        ) -> BlockHeader {
+        ) -> block::Header {
         let mut fake_header = real_header;
         fake_header.solution = fake_solution;
         fake_header
@@ -52,12 +52,12 @@ fn equihash_prop_test_solution() -> color_eyre::eyre::Result<()> {
 }
 
 prop_compose! {
-    fn randomized_nonce(real_header: BlockHeader)
+    fn randomized_nonce(real_header: block::Header)
         (fake_nonce in proptest::array::uniform32(any::<u8>())
             .prop_filter("nonce must not be the actual nonce", move |fake_nonce| {
                 fake_nonce != &real_header.nonce
             })
-        ) -> BlockHeader {
+        ) -> block::Header {
             let mut fake_header = real_header;
             fake_header.nonce = fake_nonce;
             fake_header
@@ -84,8 +84,8 @@ fn equihash_prop_test_nonce() -> color_eyre::eyre::Result<()> {
 }
 
 prop_compose! {
-    fn randomized_input(real_header: BlockHeader)
-        (fake_header in any::<BlockHeader>()
+    fn randomized_input(real_header: block::Header)
+        (fake_header in any::<block::Header>()
             .prop_map(move |mut fake_header| {
                 fake_header.nonce = real_header.nonce;
                 fake_header.solution = real_header.solution;
@@ -94,7 +94,7 @@ prop_compose! {
             .prop_filter("input must not be the actual input", move |fake_header| {
                 fake_header != &real_header
             })
-        ) -> BlockHeader {
+        ) -> block::Header {
             fake_header
     }
 }

zebra-consensus/src/block/tests.rs

@@ -6,7 +6,6 @@ use chrono::Utc;
 use color_eyre::eyre::{eyre, Report};
 use once_cell::sync::Lazy;
 
-use zebra_chain::block::BlockHeader;
 use zebra_chain::block::{self, Block};
 use zebra_chain::serialization::{ZcashDeserialize, ZcashDeserializeInto};
 use zebra_test::transcript::{TransError, Transcript};
@@ -55,7 +54,7 @@ static INVALID_HEADER_SOLUTION_TRANSCRIPT: Lazy<
 static INVALID_COINBASE_TRANSCRIPT: Lazy<Vec<(Arc<Block>, Result<block::Hash, TransError>)>> =
     Lazy::new(|| {
         let header =
-            BlockHeader::zcash_deserialize(&zebra_test::vectors::DUMMY_HEADER[..]).unwrap();
+            block::Header::zcash_deserialize(&zebra_test::vectors::DUMMY_HEADER[..]).unwrap();
 
         // Test 1: Empty transaction
         let block1 = Block {

zebra-consensus/src/chain/tests.rs

@@ -11,7 +11,7 @@ use tower::{layer::Layer, timeout::TimeoutLayer, Service, ServiceExt};
 use tracing_futures::Instrument;
 
 use zebra_chain::{
-    block::{self, Block, BlockHeader},
+    block::{self, Block},
     parameters::Network,
     serialization::ZcashDeserialize,
 };
@@ -39,7 +39,7 @@ const VERIFY_TIMEOUT_SECONDS: u64 = 10;
 /// The generated block should fail validation.
 pub fn block_no_transactions() -> Block {
     Block {
-        header: BlockHeader::zcash_deserialize(&zebra_test::vectors::DUMMY_HEADER[..]).unwrap(),
+        header: block::Header::zcash_deserialize(&zebra_test::vectors::DUMMY_HEADER[..]).unwrap(),
         transactions: Vec::new(),
     }
 }

zebra-network/src/protocol/external/message.rs

@@ -5,8 +5,10 @@ use std::{net, sync::Arc};
 
 use chrono::{DateTime, Utc};
 
-use zebra_chain::block::{self, Block};
-use zebra_chain::{block::BlockHeader, transaction::Transaction};
+use zebra_chain::{
+    block::{self, Block},
+    transaction::Transaction,
+};
 
 use super::inv::InventoryHash;
 use super::types::*;
@@ -178,7 +180,7 @@ pub enum Message {
     // transaction count (a var_int, so there can be more than 81
     // bytes per header) as opposed to the block headers that are
     // hashed by miners.
-    Headers(Vec<BlockHeader>),
+    Headers(Vec<block::Header>),
 
     /// A `getheaders` message.
     ///