feat: disable state network history header validation (#1667)

Author: KolbyML

crates/subnetworks/state/src/validation/trie.rs

@@ -13,7 +13,7 @@ use super::error::{check_node_hash, StateValidationError};
 
 /// Validate the trie proof.
 pub fn validate_node_trie_proof(
-    root_hash: B256,
+    root_hash: Option<B256>,
     node_hash: B256,
     path: &Nibbles,
     proof: &TrieProof,
@@ -33,7 +33,7 @@ pub fn validate_node_trie_proof(
 
 /// Validate the trie proof associated with the account state.
 pub fn validate_account_state(
-    root_hash: B256,
+    root_hash: Option<B256>,
     address_hash: &B256,
     proof: &TrieProof,
 ) -> Result<AccountState, StateValidationError> {
@@ -58,7 +58,7 @@ pub fn validate_account_state(
 /// - last node in the proof (whose presence we are proving)
 /// - remaining (unused) nibbles from the path
 fn validate_trie_proof<'proof, 'path>(
-    root_hash: B256,
+    root_hash: Option<B256>,
     path: &'path [u8],
     proof: &'proof TrieProof,
 ) -> Result<(&'proof EncodedTrieNode, &'path [u8]), StateValidationError> {
@@ -68,7 +68,9 @@ fn validate_trie_proof<'proof, 'path>(
     };
 
     // Check root hash
-    check_node_hash(first_node, &root_hash)?;
+    if let Some(root_hash) = &root_hash {
+        check_node_hash(first_node, root_hash)?;
+    }
 
     let mut node = first_node;
     let mut remaining_path = path;
@@ -160,7 +162,7 @@ mod tests {
         let path = Nibbles::try_from_unpacked_nibbles(&[]).unwrap();
         let proof = TrieProof::from(vec![node.clone()]);
 
-        assert!(validate_node_trie_proof(node_hash, node_hash, &path, &proof).is_ok());
+        assert!(validate_node_trie_proof(Some(node_hash), node_hash, &path, &proof).is_ok());
     }
 
     #[test]
@@ -175,7 +177,7 @@ mod tests {
         let proof = TrieProof::from(vec![root_node.clone(), last_node.clone()]);
 
         assert!(validate_node_trie_proof(
-            root_node.node_hash(),
+            Some(root_node.node_hash()),
             last_node.node_hash(),
             &path,
             &proof,
@@ -208,7 +210,7 @@ mod tests {
         ]);
 
         assert!(validate_node_trie_proof(
-            root_node.node_hash(),
+            Some(root_node.node_hash()),
             last_node.node_hash(),
             &path,
             &proof,
@@ -228,8 +230,13 @@ mod tests {
         let path = Nibbles::try_from_unpacked_nibbles(&[4, 3, 2, 1]).unwrap();
         let proof = TrieProof::from(vec![root_node.clone(), last_node.clone()]);
 
-        validate_node_trie_proof(root_node.node_hash(), last_node.node_hash(), &path, &proof)
-            .unwrap();
+        validate_node_trie_proof(
+            Some(root_node.node_hash()),
+            last_node.node_hash(),
+            &path,
+            &proof,
+        )
+        .unwrap();
     }
 
     #[test]
@@ -246,8 +253,13 @@ mod tests {
 
         // This should be the hash of the last_node, and it should fail if it is anything else
         let wrong_last_node_hash = root_node.node_hash();
-        validate_node_trie_proof(root_node.node_hash(), wrong_last_node_hash, &path, &proof)
-            .unwrap();
+        validate_node_trie_proof(
+            Some(root_node.node_hash()),
+            wrong_last_node_hash,
+            &path,
+            &proof,
+        )
+        .unwrap();
     }
 
     #[test]
@@ -280,7 +292,11 @@ mod tests {
           ].map(|trie_node| EncodedTrieNode::from(hex_decode(trie_node).unwrap()));
 
         assert_eq!(
-            validate_account_state(state_root, &address_hash, &account_proof.to_vec().into())?,
+            validate_account_state(
+                Some(state_root),
+                &address_hash,
+                &account_proof.to_vec().into()
+            )?,
             account_state
         );
 
@@ -299,7 +315,8 @@ mod tests {
         };
         let node = EncodedTrieNode::from(&create_leaf(&path, &alloy::rlp::encode(&account_state)));
         assert_eq!(
-            validate_account_state(node.node_hash(), &address_hash, &vec![node].into()).unwrap(),
+            validate_account_state(Some(node.node_hash()), &address_hash, &vec![node].into())
+                .unwrap(),
             account_state
         );
     }
@@ -309,7 +326,7 @@ mod tests {
     fn validate_account_state_last_node_is_not_leaf() {
         let address_hash = B256::random();
         let node = EncodedTrieNode::from(&create_branch());
-        validate_account_state(node.node_hash(), &address_hash, &vec![node].into()).unwrap();
+        validate_account_state(Some(node.node_hash()), &address_hash, &vec![node].into()).unwrap();
     }
 
     #[test]
@@ -327,7 +344,7 @@ mod tests {
             code_hash: B256::random(),
         };
         let node = EncodedTrieNode::from(&create_leaf(&path, &alloy::rlp::encode(account_state)));
-        validate_account_state(node.node_hash(), &address_hash, &vec![node].into()).unwrap();
+        validate_account_state(Some(node.node_hash()), &address_hash, &vec![node].into()).unwrap();
     }
 
     #[test]
@@ -336,15 +353,15 @@ mod tests {
         let address_hash = B256::random();
         let path = Nibbles::unpack_nibbles(address_hash.as_slice());
         let node = EncodedTrieNode::from(&create_leaf(&path, &[0x12, 0x34]));
-        validate_account_state(node.node_hash(), &address_hash, &vec![node].into()).unwrap();
+        validate_account_state(Some(node.node_hash()), &address_hash, &vec![node].into()).unwrap();
     }
 
     #[test]
     #[should_panic = "DecodingNode"]
     fn validate_account_state_non_decodable_leaf() {
         let address_hash = B256::random();
         let node = EncodedTrieNode::from(vec![0x12, 0x34]);
-        validate_account_state(node.node_hash(), &address_hash, &vec![node].into()).unwrap();
+        validate_account_state(Some(node.node_hash()), &address_hash, &vec![node].into()).unwrap();
     }
 
     #[test]
@@ -356,7 +373,7 @@ mod tests {
 
         let proof = TrieProof::from(vec![node.clone()]);
         let path = [2, 3, 4];
-        let validation_info = validate_trie_proof(node.node_hash(), &path, &proof).unwrap();
+        let validation_info = validate_trie_proof(Some(node.node_hash()), &path, &proof).unwrap();
 
         assert_eq!(validation_info, (&node, path.as_slice()));
     }
@@ -370,7 +387,7 @@ mod tests {
 
         let proof = TrieProof::from(vec![node.clone()]);
         let path = [2, 3, 4];
-        let validation_info = validate_trie_proof(node.node_hash(), &path, &proof).unwrap();
+        let validation_info = validate_trie_proof(Some(node.node_hash()), &path, &proof).unwrap();
 
         assert_eq!(validation_info, (&node, path.as_slice()));
     }
@@ -398,7 +415,8 @@ mod tests {
             branch_node,
             last_node.clone(),
         ]);
-        let validation_info = validate_trie_proof(root_node.node_hash(), &path, &proof).unwrap();
+        let validation_info =
+            validate_trie_proof(Some(root_node.node_hash()), &path, &proof).unwrap();
 
         assert_eq!(validation_info, (&last_node, &path[4..]));
     }
@@ -416,11 +434,11 @@ mod tests {
 
         // First verify that correct order pass the validation
         let proof = TrieProof::from(vec![root_node.clone(), last_node.clone()]);
-        assert!(validate_trie_proof(root_node.node_hash(), &[2, 1], &proof).is_ok());
+        assert!(validate_trie_proof(Some(root_node.node_hash()), &[2, 1], &proof).is_ok());
 
         // Now verify that wrong order fails because root hash doesn't match
         let proof = TrieProof::from(vec![last_node.clone(), root_node.clone()]);
-        let error = validate_trie_proof(root_node.node_hash(), &[2, 1], &proof).unwrap_err();
+        let error = validate_trie_proof(Some(root_node.node_hash()), &[2, 1], &proof).unwrap_err();
         assert!(matches!(
             error,
             StateValidationError::InvalidNodeHash {
@@ -431,7 +449,7 @@ mod tests {
 
         // And that if fails even if root hash that corresponds to the first node is given
         let proof = TrieProof::from(vec![last_node.clone(), root_node.clone()]);
-        let error = validate_trie_proof(last_node.node_hash(), &[2, 1], &proof).unwrap_err();
+        let error = validate_trie_proof(Some(last_node.node_hash()), &[2, 1], &proof).unwrap_err();
         dbg!(&error);
         dbg!(last_node.node_hash());
         assert!(matches!(
@@ -443,7 +461,7 @@ mod tests {
         ));
 
         // And that it fails even if we reverse order in path
-        let error = validate_trie_proof(last_node.node_hash(), &[1, 2], &proof).unwrap_err();
+        let error = validate_trie_proof(Some(last_node.node_hash()), &[1, 2], &proof).unwrap_err();
         assert!(matches!(
             error,
             StateValidationError::InvalidNodeHash {
@@ -456,14 +474,14 @@ mod tests {
     #[test]
     #[should_panic = "EmptyTrieProof"]
     fn validate_trie_proof_empty_proof() {
-        validate_trie_proof(B256::random(), &[], &TrieProof::default()).unwrap();
+        validate_trie_proof(Some(B256::random()), &[], &TrieProof::default()).unwrap();
     }
 
     #[test]
     #[should_panic = "InvalidNodeHash"]
     fn validate_trie_proof_invalid_root_hash() {
         let node = Node::from_branch(empty_children(), None);
         let proof = TrieProof::from(vec![EncodedTrieNode::from(&node)]);
-        validate_trie_proof(B256::random(), &[], &proof).unwrap();
+        validate_trie_proof(Some(B256::random()), &[], &proof).unwrap();
     }
 }

crates/subnetworks/state/src/validation/validator.rs

@@ -19,6 +19,9 @@ use super::{
     trie::{validate_account_state, validate_node_trie_proof},
 };
 
+// todo: remove this constant once the history network implements full chain header validation
+const DISABLE_HISTORY_HEADER_CHECK: bool = true;
+
 pub struct StateValidator {
     pub header_oracle: Arc<RwLock<HeaderOracle>>,
 }
@@ -58,7 +61,10 @@ impl StateValidator {
                 Ok(ValidationResult::new(/* valid_for_storing= */ false))
             }
             StateContentValue::AccountTrieNodeWithProof(value) => {
-                let state_root = self.get_state_root(value.block_hash).await?;
+                let state_root = match DISABLE_HISTORY_HEADER_CHECK {
+                    true => None,
+                    false => Some(self.get_state_root(value.block_hash).await?),
+                };
                 validate_node_trie_proof(state_root, key.node_hash, &key.path, &value.proof)?;
 
                 Ok(ValidationResult::new(/* valid_for_storing= */ true))
@@ -80,11 +86,14 @@ impl StateValidator {
                 Ok(ValidationResult::new(/* valid_for_storing= */ false))
             }
             StateContentValue::ContractStorageTrieNodeWithProof(value) => {
-                let state_root = self.get_state_root(value.block_hash).await?;
+                let state_root = match DISABLE_HISTORY_HEADER_CHECK {
+                    true => None,
+                    false => Some(self.get_state_root(value.block_hash).await?),
+                };
                 let account_state =
                     validate_account_state(state_root, &key.address_hash, &value.account_proof)?;
                 validate_node_trie_proof(
-                    account_state.storage_root,
+                    Some(account_state.storage_root),
                     key.node_hash,
                     &key.path,
                     &value.storage_proof,
@@ -124,7 +133,10 @@ impl StateValidator {
                     });
                 }
 
-                let state_root = self.get_state_root(value.block_hash).await?;
+                let state_root = match DISABLE_HISTORY_HEADER_CHECK {
+                    true => None,
+                    false => Some(self.get_state_root(value.block_hash).await?),
+                };
                 let account_state =
                     validate_account_state(state_root, &key.address_hash, &value.account_proof)?;
                 if account_state.code_hash == key.code_hash {