diff --git a/crates/blockchain/blockchain.rs b/crates/blockchain/blockchain.rs index a313e574699..420f3e64710 100644 --- a/crates/blockchain/blockchain.rs +++ b/crates/blockchain/blockchain.rs @@ -347,7 +347,7 @@ impl Blockchain { if used_trie_nodes.is_empty() && let Some(root) = root_node { - used_trie_nodes.push(root.encode_raw()); + used_trie_nodes.push(root.encode_to_vec()); } let mut needed_block_numbers = block_hashes.keys().collect::>(); diff --git a/crates/common/trie/logger.rs b/crates/common/trie/logger.rs index e1473dd252f..8bb24885e2f 100644 --- a/crates/common/trie/logger.rs +++ b/crates/common/trie/logger.rs @@ -3,7 +3,7 @@ use std::{ sync::{Arc, Mutex}, }; -use ethrex_rlp::decode::RLPDecode; +use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode}; use crate::{Nibbles, Node, Trie, TrieDB, TrieError}; @@ -39,7 +39,7 @@ impl TrieDB for TrieLogger { && let Ok(decoded) = Node::decode(result) { let mut lock = self.witness.lock().map_err(|_| TrieError::LockError)?; - lock.insert(decoded.encode_raw()); + lock.insert(decoded.encode_to_vec()); } Ok(result) } diff --git a/crates/common/trie/node.rs b/crates/common/trie/node.rs index e04af0c1ac8..a480a7997b8 100644 --- a/crates/common/trie/node.rs +++ b/crates/common/trie/node.rs @@ -2,18 +2,10 @@ mod branch; mod extension; mod leaf; -use std::{ - array, - sync::{Arc, OnceLock}, -}; +use std::sync::{Arc, OnceLock}; pub use branch::BranchNode; -use ethrex_rlp::{ - decode::{RLPDecode, decode_bytes}, - encode::RLPEncode, - error::RLPDecodeError, - structs::Decoder, -}; +use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode}; pub use extension::ExtensionNode; pub use leaf::LeafNode; @@ -35,7 +27,7 @@ impl NodeRef { match *self { NodeRef::Node(ref node, _) => Ok(Some(node.as_ref().clone())), NodeRef::Hash(NodeHash::Inline((data, len))) => { - Ok(Some(Node::decode_raw(&data[..len as usize])?)) + Ok(Some(Node::decode(&data[..len as usize])?)) } NodeRef::Hash(hash) => db .get(path)? @@ -69,11 +61,13 @@ impl NodeRef { } Node::Leaf(_) => {} } - let hash = *hash.get_or_init(|| node.compute_hash()); + let mut buf = Vec::new(); + node.encode(&mut buf); + let hash = *hash.get_or_init(|| NodeHash::from_encoded(&buf)); if let Node::Leaf(leaf) = node.as_ref() { acc.push((path.concat(&leaf.partial), leaf.value.clone())); } - acc.push((path.clone(), node.encode_to_vec())); + acc.push((path.clone(), buf)); *self = hash.into(); @@ -218,70 +212,6 @@ impl Node { } } - /// Encodes the node - pub fn encode_raw(&self) -> Vec { - match self { - Node::Branch(n) => n.encode_raw(), - Node::Extension(n) => n.encode_raw(), - Node::Leaf(n) => n.encode_raw(), - } - } - - /// Decodes the node - pub fn decode_raw(rlp: &[u8]) -> Result { - let mut rlp_items = vec![]; - let mut decoder = Decoder::new(rlp)?; - let mut item; - // Get encoded fields - loop { - (item, decoder) = decoder.get_encoded_item()?; - rlp_items.push(item); - // Check if we reached the end or if we decoded more items than the ones we need - if decoder.is_done() || rlp_items.len() > 17 { - break; - } - } - // Deserialize into node depending on the available fields - Ok(match rlp_items.len() { - // Leaf or Extension Node - 2 => { - let (path, _) = decode_bytes(&rlp_items[0])?; - let path = Nibbles::decode_compact(path); - if path.is_leaf() { - // Decode as Leaf - let (value, _) = decode_bytes(&rlp_items[1])?; - LeafNode { - partial: path, - value: value.to_vec(), - } - .into() - } else { - // Decode as Extension - ExtensionNode { - prefix: path, - child: decode_child(&rlp_items[1]).into(), - } - .into() - } - } - // Branch Node - 17 => { - let choices = array::from_fn(|i| decode_child(&rlp_items[i]).into()); - let (value, _) = decode_bytes(&rlp_items[16])?; - BranchNode { - choices, - value: value.to_vec(), - } - .into() - } - n => { - return Err(RLPDecodeError::Custom(format!( - "Invalid arg count for Node, expected 2 or 17, got {n}" - ))); - } - }) - } - /// Computes the node's hash pub fn compute_hash(&self) -> NodeHash { match self { @@ -291,11 +221,3 @@ impl Node { } } } - -fn decode_child(rlp: &[u8]) -> NodeHash { - match decode_bytes(rlp) { - Ok((hash, &[])) if hash.len() == 32 => NodeHash::from_slice(hash), - Ok((&[], &[])) => NodeHash::default(), - _ => NodeHash::from_slice(rlp), - } -} diff --git a/crates/common/trie/node/branch.rs b/crates/common/trie/node/branch.rs index 65434383bc4..ec972ea5030 100644 --- a/crates/common/trie/node/branch.rs +++ b/crates/common/trie/node/branch.rs @@ -1,4 +1,4 @@ -use ethrex_rlp::structs::Encoder; +use ethrex_rlp::encode::RLPEncode; use crate::{ InconsistentTreeError, TrieDB, ValueRLP, error::TrieError, nibbles::Nibbles, @@ -248,25 +248,7 @@ impl BranchNode { /// Computes the node's hash pub fn compute_hash(&self) -> NodeHash { - NodeHash::from_encoded_raw(&self.encode_raw()) - } - - /// Encodes the node - pub fn encode_raw(&self) -> Vec { - let mut buf = vec![]; - let mut encoder = Encoder::new(&mut buf); - for child in self.choices.iter() { - match child.compute_hash() { - NodeHash::Hashed(hash) => encoder = encoder.encode_bytes(&hash.0), - child @ NodeHash::Inline(raw) if raw.1 != 0 => { - encoder = encoder.encode_raw(child.as_ref()) - } - _ => encoder = encoder.encode_bytes(&[]), - } - } - encoder = encoder.encode_bytes(&self.value); - encoder.finish(); - buf + NodeHash::from_encoded(&self.encode_to_vec()) } /// Traverses own subtrie until reaching the node containing `path` @@ -279,7 +261,7 @@ impl BranchNode { node_path: &mut Vec>, ) -> Result<(), TrieError> { // Add self to node_path (if not inlined in parent) - let encoded = self.encode_raw(); + let encoded = self.encode_to_vec(); if encoded.len() >= 32 { node_path.push(encoded); }; @@ -307,6 +289,7 @@ impl BranchNode { #[cfg(test)] mod test { use ethereum_types::H256; + use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode}; use super::*; @@ -654,7 +637,7 @@ mod test { } } .into(); - assert_eq!(Node::decode_raw(&node.encode_raw()).unwrap(), node) + assert_eq!(Node::decode(&node.encode_to_vec()).unwrap(), node) } #[test] @@ -670,7 +653,7 @@ mod test { } } .into(); - assert_eq!(Node::decode_raw(&node.encode_raw()).unwrap(), node) + assert_eq!(Node::decode(&node.encode_to_vec()).unwrap(), node) } #[test] @@ -696,6 +679,6 @@ mod test { } with_leaf { &[0x1] => vec![0x1] } } .into(); - assert_eq!(Node::decode_raw(&node.encode_raw()).unwrap(), node) + assert_eq!(Node::decode(&node.encode_to_vec()).unwrap(), node) } } diff --git a/crates/common/trie/node/extension.rs b/crates/common/trie/node/extension.rs index 4a99a3ff7ca..6d600354a20 100644 --- a/crates/common/trie/node/extension.rs +++ b/crates/common/trie/node/extension.rs @@ -1,4 +1,4 @@ -use ethrex_rlp::structs::Encoder; +use ethrex_rlp::encode::RLPEncode; use crate::ValueRLP; use crate::nibbles::Nibbles; @@ -190,16 +190,7 @@ impl ExtensionNode { /// Computes the node's hash pub fn compute_hash(&self) -> NodeHash { - NodeHash::from_encoded_raw(&self.encode_raw()) - } - - /// Encodes the node - pub fn encode_raw(&self) -> Vec { - let mut buf = vec![]; - let mut encoder = Encoder::new(&mut buf).encode_bytes(&self.prefix.encode_compact()); - encoder = self.child.compute_hash().encode(encoder); - encoder.finish(); - buf + NodeHash::from_encoded(&self.encode_to_vec()) } /// Traverses own subtrie until reaching the node containing `path` @@ -212,7 +203,7 @@ impl ExtensionNode { node_path: &mut Vec>, ) -> Result<(), TrieError> { // Add self to node_path (if not inlined in parent) - let encoded = self.encode_raw(); + let encoded = self.encode_to_vec(); if encoded.len() >= 32 { node_path.push(encoded); }; @@ -236,6 +227,8 @@ impl ExtensionNode { #[cfg(test)] mod test { + use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode}; + use super::*; use crate::{Trie, node::LeafNode, pmt_node}; @@ -544,7 +537,7 @@ mod test { } } } .into(); - assert_eq!(Node::decode_raw(&node.encode_raw()).unwrap(), node) + assert_eq!(Node::decode(&node.encode_to_vec()).unwrap(), node) } #[test] @@ -560,7 +553,7 @@ mod test { } .into(); - assert_eq!(Node::decode_raw(&node.encode_raw()).unwrap(), node) + assert_eq!(Node::decode(&node.encode_to_vec()).unwrap(), node) } #[test] @@ -585,6 +578,6 @@ mod test { } } } .into(); - assert_eq!(Node::decode_raw(&node.encode_raw()).unwrap(), node) + assert_eq!(Node::decode(&node.encode_to_vec()).unwrap(), node) } } diff --git a/crates/common/trie/node/leaf.rs b/crates/common/trie/node/leaf.rs index 831cf3de3e4..098a4831175 100644 --- a/crates/common/trie/node/leaf.rs +++ b/crates/common/trie/node/leaf.rs @@ -1,4 +1,4 @@ -use ethrex_rlp::structs::Encoder; +use ethrex_rlp::encode::RLPEncode; use crate::{ValueRLP, error::TrieError, nibbles::Nibbles, node::BranchNode, node_hash::NodeHash}; @@ -115,22 +115,12 @@ impl LeafNode { /// Computes the node's hash pub fn compute_hash(&self) -> NodeHash { - NodeHash::from_encoded_raw(&self.encode_raw()) - } - - /// Encodes the node - pub fn encode_raw(&self) -> Vec { - let mut buf = vec![]; - Encoder::new(&mut buf) - .encode_bytes(&self.partial.encode_compact()) - .encode_bytes(&self.value) - .finish(); - buf + NodeHash::from_encoded(&self.encode_to_vec()) } /// Encodes the node and appends it to `node_path` if the encoded node is 32 or more bytes long pub fn get_path(&self, node_path: &mut Vec>) -> Result<(), TrieError> { - let encoded = self.encode_raw(); + let encoded = self.encode_to_vec(); if encoded.len() >= 32 { node_path.push(encoded); } @@ -140,6 +130,8 @@ impl LeafNode { #[cfg(test)] mod test { + use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode}; + use super::*; use crate::{Trie, pmt_node}; @@ -321,7 +313,7 @@ mod test { b"a comparatively long value".to_vec(), ) .into(); - assert_eq!(Node::decode_raw(&node.encode_raw()).unwrap(), node) + assert_eq!(Node::decode(&node.encode_to_vec()).unwrap(), node) } #[test] @@ -331,7 +323,7 @@ mod test { vec![0x12, 0x34, 0x56, 0x78], ) .into(); - assert_eq!(Node::decode_raw(&node.encode_raw()).unwrap(), node) + assert_eq!(Node::decode(&node.encode_to_vec()).unwrap(), node) } #[test] @@ -341,6 +333,6 @@ mod test { vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 20], ) .into(); - assert_eq!(Node::decode_raw(&node.encode_raw()).unwrap(), node) + assert_eq!(Node::decode(&node.encode_to_vec()).unwrap(), node) } } diff --git a/crates/common/trie/node_hash.rs b/crates/common/trie/node_hash.rs index 5588a50f659..689c4752ed9 100644 --- a/crates/common/trie/node_hash.rs +++ b/crates/common/trie/node_hash.rs @@ -24,7 +24,7 @@ impl AsRef<[u8]> for NodeHash { impl NodeHash { /// Returns the `NodeHash` of an encoded node (encoded using the NodeEncoder) - pub fn from_encoded_raw(encoded: &[u8]) -> NodeHash { + pub fn from_encoded(encoded: &[u8]) -> NodeHash { if encoded.len() >= 32 { let hash = Keccak256::new_with_prefix(encoded).finalize(); NodeHash::Hashed(H256::from_slice(hash.as_slice())) @@ -35,7 +35,7 @@ impl NodeHash { /// Converts a slice of an already hashed data (in case it's not inlineable) to a NodeHash. /// Panics if the slice is over 32 bytes - /// If you need to hash it in case its len >= 32 see `from_encoded_raw` + /// If you need to hash it in case its len >= 32 see `from_encoded` pub(crate) fn from_slice(slice: &[u8]) -> NodeHash { match slice.len() { 0..32 => { diff --git a/crates/common/trie/rlp.rs b/crates/common/trie/rlp.rs index 40e66941371..d09dc2853b8 100644 --- a/crates/common/trie/rlp.rs +++ b/crates/common/trie/rlp.rs @@ -1,113 +1,53 @@ +use std::array; + // Contains RLP encoding and decoding implementations for Trie Nodes // This encoding is only used to store the nodes in the DB, it is not the encoding used for hash computation use ethrex_rlp::{ - decode::RLPDecode, + decode::{RLPDecode, decode_bytes}, encode::RLPEncode, error::RLPDecodeError, structs::{Decoder, Encoder}, }; use super::node::{BranchNode, ExtensionNode, LeafNode, Node}; -use crate::{NodeHash, node::NodeRef}; - -enum NodeType { - Branch = 0, - Extension = 1, - Leaf = 2, -} - -impl NodeType { - const fn from_u8(val: u8) -> Option { - match val { - 0 => Some(Self::Branch), - 1 => Some(Self::Extension), - 2 => Some(Self::Leaf), - _ => None, - } - } -} +use crate::{Nibbles, NodeHash}; impl RLPEncode for BranchNode { fn encode(&self, buf: &mut dyn bytes::BufMut) { - // TODO: choices encoded as vec due to conflicting trait impls for [T;N] & [u8;N], check if we can fix this later - Encoder::new(buf) - .encode_field( - &self - .choices - .iter() - .map(|x| x.compute_hash()) - .collect::>(), - ) - .encode_field(&self.value) - .finish() + let mut encoder = Encoder::new(buf); + for child in self.choices.iter() { + match child.compute_hash() { + NodeHash::Hashed(hash) => encoder = encoder.encode_bytes(&hash.0), + child @ NodeHash::Inline(raw) if raw.1 != 0 => { + encoder = encoder.encode_raw(child.as_ref()) + } + _ => encoder = encoder.encode_bytes(&[]), + } + } + encoder = encoder.encode_bytes(&self.value); + encoder.finish(); } } impl RLPEncode for ExtensionNode { fn encode(&self, buf: &mut dyn bytes::BufMut) { - Encoder::new(buf) - .encode_field(&self.prefix) - .encode_field(&self.child.compute_hash()) - .finish() + let mut encoder = Encoder::new(buf).encode_bytes(&self.prefix.encode_compact()); + encoder = self.child.compute_hash().encode(encoder); + encoder.finish(); } } impl RLPEncode for LeafNode { fn encode(&self, buf: &mut dyn bytes::BufMut) { Encoder::new(buf) - .encode_field(&self.partial) - .encode_field(&self.value) + .encode_bytes(&self.partial.encode_compact()) + .encode_bytes(&self.value) .finish() } } -impl RLPDecode for BranchNode { - fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> { - const CHOICES_LEN_ERROR_MSG: &str = - "Error decoding field 'choices' of type [H256;16]: Invalid Length"; - let decoder = Decoder::new(rlp)?; - let (choices, decoder) = decoder.decode_field::>("choices")?; - let choices = choices.into_iter().map(NodeRef::Hash).collect::>(); - let choices = choices - .try_into() - .map_err(|_| RLPDecodeError::Custom(CHOICES_LEN_ERROR_MSG.to_string()))?; - let (value, decoder) = decoder.decode_field("value")?; - Ok((Self { choices, value }, decoder.finish()?)) - } -} - -impl RLPDecode for ExtensionNode { - fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> { - let decoder = Decoder::new(rlp)?; - let (prefix, decoder) = decoder.decode_field("prefix")?; - let (child, decoder) = decoder.decode_field("child")?; - Ok(( - Self { - prefix, - child: NodeRef::Hash(child), - }, - decoder.finish()?, - )) - } -} - -impl RLPDecode for LeafNode { - fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> { - let decoder = Decoder::new(rlp)?; - let (partial, decoder) = decoder.decode_field("partial")?; - let (value, decoder) = decoder.decode_field("value")?; - Ok((Self { partial, value }, decoder.finish()?)) - } -} - impl RLPEncode for Node { fn encode(&self, buf: &mut dyn bytes::BufMut) { - let node_type = match self { - Node::Branch(_) => NodeType::Branch, - Node::Extension(_) => NodeType::Extension, - Node::Leaf(_) => NodeType::Leaf, - }; - buf.put_u8(node_type as u8); match self { Node::Branch(n) => n.encode(buf), Node::Extension(n) => n.encode(buf), @@ -118,19 +58,65 @@ impl RLPEncode for Node { impl RLPDecode for Node { fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> { - let node_type = rlp.first().ok_or(RLPDecodeError::InvalidLength)?; - let node_type = NodeType::from_u8(*node_type).ok_or(RLPDecodeError::MalformedData)?; - let rlp = &rlp[1..]; - match node_type { - NodeType::Branch => { - BranchNode::decode_unfinished(rlp).map(|(node, rem)| (node.into(), rem)) - } - NodeType::Extension => { - ExtensionNode::decode_unfinished(rlp).map(|(node, rem)| (node.into(), rem)) - } - NodeType::Leaf => { - LeafNode::decode_unfinished(rlp).map(|(node, rem)| (node.into(), rem)) - } + let mut rlp_items = vec![]; + let mut decoder = Decoder::new(rlp)?; + let mut item; + // Get encoded fields + + // Check if we reached the end or if we decoded more items than the ones we need + while !decoder.is_done() && rlp_items.len() <= 17 { + (item, decoder) = decoder.get_encoded_item()?; + rlp_items.push(item); } + // Deserialize into node depending on the available fields + Ok(( + match rlp_items.len() { + // Leaf or Extension Node + 2 => { + let (path, _) = decode_bytes(&rlp_items[0])?; + let path = Nibbles::decode_compact(path); + if path.is_leaf() { + // Decode as Leaf + let (value, _) = decode_bytes(&rlp_items[1])?; + LeafNode { + partial: path, + value: value.to_vec(), + } + .into() + } else { + // Decode as Extension + ExtensionNode { + prefix: path, + child: decode_child(&rlp_items[1]).into(), + } + .into() + } + } + // Branch Node + 17 => { + let choices = array::from_fn(|i| decode_child(&rlp_items[i]).into()); + let (value, _) = decode_bytes(&rlp_items[16])?; + BranchNode { + choices, + value: value.to_vec(), + } + .into() + } + n => { + return Err(RLPDecodeError::Custom(format!( + "Invalid arg count for Node, expected 2 or 17, got {n}" + ))); + } + }, + decoder.finish()?, + )) + } +} + +fn decode_child(rlp: &[u8]) -> NodeHash { + match decode_bytes(rlp) { + Ok((hash, &[])) if hash.len() == 32 => NodeHash::from_slice(hash), + Ok((&[], &[])) => NodeHash::default(), + _ => NodeHash::from_slice(rlp), } } diff --git a/crates/common/trie/trie.rs b/crates/common/trie/trie.rs index 2907d1a600b..ebbdc4996b4 100644 --- a/crates/common/trie/trie.rs +++ b/crates/common/trie/trie.rs @@ -12,6 +12,7 @@ pub mod trie_sorted; mod verify_range; use ethereum_types::H256; use ethrex_rlp::constants::RLP_NULL; +use ethrex_rlp::encode::RLPEncode; use sha3::{Digest, Keccak256}; use std::collections::{BTreeMap, HashSet}; use std::sync::{Arc, Mutex}; @@ -262,7 +263,7 @@ impl Trie { paths: &[PathRLP], ) -> Result<(Option, Vec), TrieError> { if self.root.is_valid() { - let encoded_root = self.get_root_node(Nibbles::default())?.encode_raw(); + let encoded_root = self.get_root_node(Nibbles::default())?.encode_to_vec(); let mut node_path = HashSet::new(); for path in paths { @@ -301,7 +302,7 @@ impl Trie { all_nodes: &BTreeMap>, cur_node_rlp: &[u8], ) -> Result { - let cur_node = Node::decode_raw(cur_node_rlp)?; + let cur_node = Node::decode(cur_node_rlp)?; Ok(match cur_node { Node::Branch(mut node) => { @@ -411,7 +412,7 @@ impl Trie { ) -> Result, TrieError> { // If we reached the end of the partial path, return the current node if partial_path.is_empty() { - return Ok(node.encode_raw()); + return Ok(node.encode_to_vec()); } match node { Node::Branch(branch_node) => match partial_path.next_choice() { diff --git a/crates/common/trie/verify_range.rs b/crates/common/trie/verify_range.rs index adb35f4ca11..ac81a5ad124 100644 --- a/crates/common/trie/verify_range.rs +++ b/crates/common/trie/verify_range.rs @@ -1,6 +1,7 @@ use std::collections::{BTreeMap, VecDeque}; use ethereum_types::H256; +use ethrex_rlp::decode::RLPDecode; use sha3::{Digest, Keccak256}; use crate::{ @@ -159,7 +160,7 @@ impl RangeProof<'_> { NodeHash::Hashed(hash) => self.node_refs.get(&hash).copied(), NodeHash::Inline(_) => Some(hash.as_ref()), }; - Ok(encoded_node.map(Node::decode_raw).transpose()?) + Ok(encoded_node.map(Node::decode).transpose()?) } } diff --git a/crates/networking/p2p/peer_handler.rs b/crates/networking/p2p/peer_handler.rs index a06d1db806d..a7c762acb66 100644 --- a/crates/networking/p2p/peer_handler.rs +++ b/crates/networking/p2p/peer_handler.rs @@ -30,7 +30,7 @@ use ethrex_common::{ BigEndianHash, H256, U256, types::{AccountState, BlockBody, BlockHeader, Receipt, validate_block_body}, }; -use ethrex_rlp::encode::RLPEncode; +use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode}; use ethrex_storage::Store; use ethrex_trie::Nibbles; use ethrex_trie::{Node, verify_range}; @@ -1851,7 +1851,7 @@ impl PeerHandler { Ok(RLPxMessage::TrieNodes(trie_nodes)) => trie_nodes .nodes .iter() - .map(|node| Node::decode_raw(node)) + .map(|node| Node::decode(node)) .collect::, _>>() .map_err(|e| { RequestStateTrieNodesError::RequestError(PeerConnectionError::RLPDecodeError(e)) diff --git a/crates/networking/p2p/sync/storage_healing.rs b/crates/networking/p2p/sync/storage_healing.rs index 6e4f1f1aada..91d20498ccd 100644 --- a/crates/networking/p2p/sync/storage_healing.rs +++ b/crates/networking/p2p/sync/storage_healing.rs @@ -437,7 +437,7 @@ async fn zip_requeue_node_responses_score_peer( .iter() .zip(trie_nodes.nodes.clone()) .map(|(node_request, node_bytes)| { - let node = Node::decode_raw(&node_bytes).inspect_err(|err|{ + let node = Node::decode(&node_bytes).inspect_err(|err|{ info!("this peer {} request {node_request:?}, had this error {err:?}, and the raw node was {node_bytes:?}", request.peer_id) })?;