remove blockheaderhash

network/src/message/message.rs

@@ -14,10 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with the snarkOS library. If not, see <https://www.gnu.org/licenses/>.
 
-use snarkvm_dpc::BlockHeaderHash;
-
 use std::{fmt, net::SocketAddr};
 
+use snarkos_storage::Digest;
+
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub enum Direction {
     Inbound(SocketAddr),
@@ -64,13 +64,13 @@ pub enum Payload {
     #[doc = include_str!("../../documentation/network_messages/block.md")]
     Block(Vec<u8>, Option<u32>),
     #[doc = include_str!("../../documentation/network_messages/get_blocks.md")]
-    GetBlocks(Vec<BlockHeaderHash>),
+    GetBlocks(Vec<Digest>),
     #[doc = include_str!("../../documentation/network_messages/get_memory_pool.md")]
     GetMemoryPool,
     #[doc = include_str!("../../documentation/network_messages/get_peers.md")]
     GetPeers,
     #[doc = include_str!("../../documentation/network_messages/get_sync.md")]
-    GetSync(Vec<BlockHeaderHash>),
+    GetSync(Vec<Digest>),
     #[doc = include_str!("../../documentation/network_messages/memory_pool.md")]
     MemoryPool(Vec<Vec<u8>>),
     #[doc = include_str!("../../documentation/network_messages/peers.md")]
@@ -80,7 +80,7 @@ pub enum Payload {
     #[doc = include_str!("../../documentation/network_messages/pong.md")]
     Pong,
     #[doc = include_str!("../../documentation/network_messages/sync.md")]
-    Sync(Vec<BlockHeaderHash>),
+    Sync(Vec<Digest>),
     #[doc = include_str!("../../documentation/network_messages/sync_block.md")]
     SyncBlock(Vec<u8>, Option<u32>),
     #[doc = include_str!("../../documentation/network_messages/transaction.md")]

network/src/message/serialization.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with the snarkOS library. If not, see <https://www.gnu.org/licenses/>.
 
-use snarkvm_dpc::BlockHeaderHash;
+use snarkos_storage::Digest;
 
 use crate::message::{Payload, Version};
 use payload_capnp::{
@@ -215,14 +215,14 @@ fn deserialize_block(block: block::Reader<'_>, is_sync: bool) -> capnp::Result<P
     Ok(payload)
 }
 
-fn deserialize_block_hashes(hashes: BlockHashes<'_>) -> capnp::Result<Vec<BlockHeaderHash>> {
+fn deserialize_block_hashes(hashes: BlockHashes<'_>) -> capnp::Result<Vec<Digest>> {
     let mut vec = Vec::with_capacity(hashes.len() as usize);
 
     for hash in hashes.iter() {
         let bytes = hash.get_hash()?;
         let mut block_hash = [0u8; 32];
         block_hash.copy_from_slice(bytes);
-        vec.push(BlockHeaderHash(block_hash));
+        vec.push(block_hash.into());
     }
 
     Ok(vec)
@@ -323,7 +323,7 @@ mod tests {
 
     #[test]
     fn serialize_deserialize_payloads_with_hashes() {
-        let hashes = (0u8..10).map(|i| BlockHeaderHash::new(vec![i; 32])).collect::<Vec<_>>();
+        let hashes = (0u8..10).map(|i| Digest::from(vec![i; 32])).collect::<Vec<_>>();
 
         for payload in &[
             Payload::GetBlocks(hashes.clone()),

network/src/sync/blocks/aggro.rs

@@ -19,7 +19,6 @@ use std::{sync::Arc, time::Duration};
 use crate::{Cache, Node, Payload, Peer, SyncBase, SyncInbound};
 use anyhow::*;
 use snarkos_storage::Digest;
-use snarkvm_dpc::BlockHeaderHash;
 use tokio::{
     sync::{mpsc, RwLock},
     time::Instant,
@@ -31,7 +30,7 @@ pub struct SyncAggro {
 }
 
 struct BlockLocatorHashes {
-    hashes: Vec<BlockHeaderHash>,
+    hashes: Vec<Digest>,
     last_update: Instant,
 }
 
@@ -42,7 +41,7 @@ impl SyncAggro {
         (new, sender)
     }
 
-    async fn send_sync_messages(&mut self, nodes: Vec<(Peer, Vec<BlockHeaderHash>)>) -> Result<usize> {
+    async fn send_sync_messages(&mut self, nodes: Vec<(Peer, Vec<Digest>)>) -> Result<usize> {
         info!("requested block information from {} peers", nodes.len());
         let mut future_set = vec![];
 
@@ -138,22 +137,17 @@ impl SyncAggro {
                                 .into_iter()
                                 .zip(early_block_states.iter())
                                 .filter(|(_, status)| matches!(status, snarkos_storage::BlockStatus::Unknown))
-                                .map(|(hash, _)| BlockHeaderHash(hash.bytes().unwrap()))
+                                .map(|(hash, _)| hash)
                                 .collect();
                             if blocks.is_empty() {
                                 return;
                             }
                             debug!("requesting {} sync blocks from {}", blocks.len(), peer);
 
                             if let Some(peer) = node.peer_book.get_peer_handle(peer) {
-                                let request: Vec<BlockHeaderHash> = blocks.into_iter().collect();
-                                peer.expecting_sync_blocks(request.len() as u32).await;
-                                peer.send_payload(Payload::GetBlocks(request), None).await;
-                                peer.send_payload(
-                                    Payload::GetSync(vec![BlockHeaderHash(last_hash.bytes().unwrap())]),
-                                    None,
-                                )
-                                .await;
+                                peer.expecting_sync_blocks(blocks.len() as u32).await;
+                                peer.send_payload(Payload::GetBlocks(blocks), None).await;
+                                peer.send_payload(Payload::GetSync(vec![last_hash]), None).await;
                             }
                         });
                     }

network/src/sync/blocks/base.rs

@@ -17,7 +17,6 @@
 use std::{net::SocketAddr, time::Duration};
 
 use snarkos_storage::Digest;
-use snarkvm_dpc::BlockHeaderHash;
 use tokio::sync::mpsc;
 
 use crate::{Node, Peer, SyncInbound};
@@ -66,11 +65,8 @@ impl SyncBase {
         Ok(interesting_peers)
     }
 
-    pub async fn block_locator_hashes(node: &Node) -> Result<Vec<BlockHeaderHash>> {
-        let forks_of_interest = node
-            .storage
-            .scan_forks(snarkos_consensus::OLDEST_FORK_THRESHOLD as u32)
-            .await?;
+    pub async fn block_locator_hashes(node: &Node) -> Result<Vec<Digest>> {
+        let forks_of_interest = node.storage.scan_forks(snarkos_consensus::OLDEST_FORK_THRESHOLD as u32).await?;
         trace!("sync found {} forks", forks_of_interest.len());
         let blocks_of_interest: Vec<Digest> = forks_of_interest.into_iter().map(|(_canon, fork)| fork).collect();
         let mut tips_of_blocks_of_interest: Vec<Digest> = Vec::with_capacity(blocks_of_interest.len());
@@ -98,10 +94,7 @@ impl SyncBase {
             }
         }?;
 
-        Ok(hashes
-            .into_iter()
-            .map(|x| BlockHeaderHash(x.bytes().unwrap()))
-            .collect::<Vec<_>>())
+        Ok(hashes)
     }
 
     /// receives an arbitrary amount of inbound sync messages with a given timeout.

network/src/sync/blocks/batched.rs

@@ -22,7 +22,7 @@ use hash_hasher::{HashBuildHasher, HashedMap, HashedSet};
 use rand::{prelude::SliceRandom, rngs::SmallRng, SeedableRng};
 use snarkos_storage::Digest;
 use snarkvm_algorithms::crh::double_sha256;
-use snarkvm_dpc::{BlockHeader, BlockHeaderHash};
+use snarkvm_dpc::BlockHeader;
 use tokio::sync::mpsc;
 
 /// Efficient but slow and fork-prone sync method that operates in distributed batches.
@@ -189,10 +189,6 @@ impl SyncBatched {
         for (addr, request) in peer_block_requests {
             if let Some(peer) = self.base.node.peer_book.get_peer_handle(addr) {
                 sent += request.len();
-                let request: Vec<BlockHeaderHash> = request
-                    .into_iter()
-                    .map(|x| BlockHeaderHash(x.bytes::<32>().unwrap()))
-                    .collect();
                 future_set.push(async move {
                     peer.expecting_sync_blocks(request.len() as u32).await;
                     peer.send_payload(Payload::GetBlocks(request), None).await;

network/src/sync/blocks/interface.rs

@@ -24,7 +24,6 @@ use snarkos_storage::{BlockStatus, Digest, VMBlock};
 use snarkvm_dpc::{
     testnet1::{instantiated::Components, Transaction},
     Block,
-    BlockHeaderHash,
 };
 
 use snarkos_consensus::error::ConsensusError;
@@ -166,7 +165,7 @@ impl Node {
     pub(crate) async fn received_get_blocks(
         &self,
         remote_address: SocketAddr,
-        header_hashes: Vec<BlockHeaderHash>,
+        header_hashes: Vec<Digest>,
         time_received: Option<Instant>,
     ) -> Result<(), NetworkError> {
         for (i, hash) in header_hashes
@@ -205,19 +204,15 @@ impl Node {
     pub(crate) async fn received_get_sync(
         &self,
         remote_address: SocketAddr,
-        block_locator_hashes: Vec<BlockHeaderHash>,
+        block_locator_hashes: Vec<Digest>,
         time_received: Option<Instant>,
     ) -> Result<(), NetworkError> {
         let block_locator_hashes = block_locator_hashes.into_iter().map(|x| x.0.into()).collect::<Vec<_>>();
 
         let sync_hashes = self
             .storage
             .find_sync_blocks(&block_locator_hashes[..], crate::MAX_BLOCK_SYNC_COUNT as usize)
-            .await?
-            .into_iter()
-            .map(|x| x.bytes::<32>().map(BlockHeaderHash))
-            .collect::<Option<Vec<_>>>()
-            .ok_or_else(|| anyhow!("invalid block header size in locator hash"))?;
+            .await?;
 
         // send a `Sync` message to the connected peer.
         self.peer_book
@@ -228,7 +223,7 @@ impl Node {
     }
 
     /// A peer has sent us their chain state.
-    pub(crate) async fn received_sync(&self, remote_address: SocketAddr, block_hashes: Vec<BlockHeaderHash>) {
+    pub(crate) async fn received_sync(&self, remote_address: SocketAddr, block_hashes: Vec<Digest>) {
         let sender = self.master_dispatch.read().await;
         if let Some(sender) = &*sender {
             sender

network/src/sync/blocks/mod.rs

@@ -22,11 +22,11 @@ mod base;
 pub use base::*;
 mod aggro;
 pub use aggro::*;
+use snarkos_storage::Digest;
 
-use snarkvm_dpc::BlockHeaderHash;
 use std::net::SocketAddr;
 
 pub enum SyncInbound {
-    BlockHashes(SocketAddr, Vec<BlockHeaderHash>),
+    BlockHashes(SocketAddr, Vec<Digest>),
     Block(SocketAddr, Vec<u8>, Option<u32>),
 }

network/tests/fuzzing.rs

@@ -15,9 +15,9 @@
 // along with the snarkOS library. If not, see <https://www.gnu.org/licenses/>.
 
 use snarkos_network::{MessageHeader, Payload, Version};
-use snarkvm_dpc::BlockHeaderHash;
 
 use rand::{distributions::Standard, thread_rng, Rng};
+use snarkos_storage::Digest;
 use snarkos_testing::{
     network::{handshaken_node_and_peer, spawn_2_fake_nodes, test_node, TestSetup},
     wait_until,
@@ -450,7 +450,7 @@ async fn fuzzing_corrupted_payloads_with_hashes_pre_handshake() {
     let node = test_node(node_setup).await;
     let node_addr = node.expect_local_addr();
 
-    let hashes: Vec<BlockHeaderHash> = (0u8..10).map(|i| BlockHeaderHash::new(vec![i; 32])).collect();
+    let hashes: Vec<Digest> = (0u8..10).map(|i| Digest::from([i; 32])).collect();
 
     for payload in &[
         Payload::GetBlocks(hashes.clone()),
@@ -491,7 +491,7 @@ async fn fuzzing_corrupted_payloads_with_hashes_post_handshake() {
         }
     });
 
-    let hashes: Vec<BlockHeaderHash> = (0u8..10).map(|i| BlockHeaderHash::new(vec![i; 32])).collect();
+    let hashes: Vec<Digest> = (0u8..10).map(|i| Digest::from([i; 32])).collect();
 
     for payload in &[
         Payload::GetBlocks(hashes.clone()),

network/tests/handshake.rs

@@ -15,13 +15,12 @@
 // along with the snarkOS library. If not, see <https://www.gnu.org/licenses/>.
 
 use snarkos_network::{message::*, Node, Version};
+use snarkos_storage::Digest;
 use snarkos_testing::{
     network::{test_node, write_message_to_stream, TestSetup},
     wait_until,
 };
 
-use snarkvm_dpc::block_header_hash::BlockHeaderHash;
-
 use std::time::Duration;
 
 use tokio::{
@@ -185,13 +184,13 @@ async fn reject_non_version_messages_before_handshake() {
 
     // GetBlock
     let mut peer_stream = TcpStream::connect(node.expect_local_addr()).await.unwrap();
-    let block_hash = BlockHeaderHash::new([0u8; 32].to_vec());
+    let block_hash = Digest::from([0u8; 32]);
     write_message_to_stream(Payload::GetBlocks(vec![block_hash]), &mut peer_stream).await;
     assert_node_rejected_message(&node, &mut peer_stream).await;
 
     // GetSync
     let mut peer_stream = TcpStream::connect(node.expect_local_addr()).await.unwrap();
-    let block_hash = BlockHeaderHash::new([0u8; 32].to_vec());
+    let block_hash = Digest::from([0u8; 32]);
     write_message_to_stream(Payload::GetSync(vec![block_hash]), &mut peer_stream).await;
     assert_node_rejected_message(&node, &mut peer_stream).await;
 
@@ -223,7 +222,7 @@ async fn reject_non_version_messages_before_handshake() {
 
     // Sync
     let mut peer_stream = TcpStream::connect(node.expect_local_addr()).await.unwrap();
-    let block_hash = BlockHeaderHash::new(vec![0u8; 32]);
+    let block_hash = Digest::from([0u8; 32]);
     write_message_to_stream(Payload::Sync(vec![block_hash]), &mut peer_stream).await;
     assert_node_rejected_message(&node, &mut peer_stream).await;
 

storage/src/validator.rs

@@ -628,7 +628,7 @@ async fn validate_block_transactions(
                         warn!(
                             "Can't get the block number for tx {}! The block locator entry for hash {} is missing",
                             hex::encode(tx.id),
-                            BlockHeaderHash(tx_location.block_hash.bytes::<32>().unwrap())
+                            tx_location.block_hash
                         );
 
                         if [FixMode::Testnet1TxLocations, FixMode::Everything].contains(&fix_mode) {

testing/src/network/sync.rs

@@ -26,7 +26,7 @@ use crate::{
 
 use snarkos_network::message::*;
 
-use snarkvm_dpc::{block_header_hash::BlockHeaderHash, testnet1::instantiated::Testnet1Transaction, Block};
+use snarkvm_dpc::{testnet1::instantiated::Testnet1Transaction, Block};
 #[cfg(test)]
 use snarkvm_utilities::ToBytes;
 
@@ -73,8 +73,8 @@ async fn block_initiator_side() {
         matches!(payload, Payload::GetSync(..))
     });
 
-    let block_1_header_hash = BlockHeaderHash::new(BLOCK_1_HEADER_HASH.to_vec());
-    let block_2_header_hash = BlockHeaderHash::new(BLOCK_2_HEADER_HASH.to_vec());
+    let block_1_header_hash = BLOCK_1_HEADER_HASH.clone();
+    let block_2_header_hash = BLOCK_2_HEADER_HASH.clone();
 
     let block_header_hashes = vec![block_1_header_hash.clone(), block_2_header_hash.clone()];