Merged with unstable

testing/ef_tests/src/cases.rs

@@ -18,6 +18,7 @@ mod fork;
 mod fork_choice;
 mod genesis_initialization;
 mod genesis_validity;
+mod merkle_proof_validity;
 mod operations;
 mod rewards;
 mod sanity_blocks;
@@ -41,6 +42,7 @@ pub use epoch_processing::*;
 pub use fork::ForkTest;
 pub use genesis_initialization::*;
 pub use genesis_validity::*;
+pub use merkle_proof_validity::*;
 pub use operations::*;
 pub use rewards::RewardsTest;
 pub use sanity_blocks::*;

testing/ef_tests/src/cases/fork_choice.rs

@@ -7,7 +7,7 @@ use beacon_chain::{
         obtain_indexed_attestation_and_committees_per_slot, VerifiedAttestation,
     },
     test_utils::{BeaconChainHarness, EphemeralHarnessType},
-    BeaconChainTypes, CachedHead, CountUnrealized,
+    BeaconChainTypes, CachedHead, CountUnrealized, NotifyExecutionLayer,
 };
 use execution_layer::{json_structures::JsonPayloadStatusV1Status, PayloadStatusV1};
 use serde::Deserialize;
@@ -388,6 +388,7 @@ impl<E: EthSpec> Tester<E> {
             block_root,
             block.clone(),
             CountUnrealized::False,
+            NotifyExecutionLayer::Yes,
         ))?;
         if result.is_ok() != valid {
             return Err(Error::DidntFail(format!(

testing/ef_tests/src/cases/merkle_proof_validity.rs

@@ -0,0 +1,87 @@
+use super::*;
+use crate::decode::{ssz_decode_state, yaml_decode_file};
+use serde_derive::Deserialize;
+use std::path::Path;
+use tree_hash::Hash256;
+use types::{BeaconState, EthSpec, ForkName};
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Metadata {
+    #[serde(rename(deserialize = "description"))]
+    _description: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct MerkleProof {
+    pub leaf: Hash256,
+    pub leaf_index: usize,
+    pub branch: Vec<Hash256>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(bound = "E: EthSpec")]
+pub struct MerkleProofValidity<E: EthSpec> {
+    pub metadata: Option<Metadata>,
+    pub state: BeaconState<E>,
+    pub merkle_proof: MerkleProof,
+}
+
+impl<E: EthSpec> LoadCase for MerkleProofValidity<E> {
+    fn load_from_dir(path: &Path, fork_name: ForkName) -> Result<Self, Error> {
+        let spec = &testing_spec::<E>(fork_name);
+        let state = ssz_decode_state(&path.join("state.ssz_snappy"), spec)?;
+        let merkle_proof = yaml_decode_file(&path.join("proof.yaml"))?;
+        // Metadata does not exist in these tests but it is left like this just in case.
+        let meta_path = path.join("meta.yaml");
+        let metadata = if meta_path.exists() {
+            Some(yaml_decode_file(&meta_path)?)
+        } else {
+            None
+        };
+
+        Ok(Self {
+            metadata,
+            state,
+            merkle_proof,
+        })
+    }
+}
+
+impl<E: EthSpec> Case for MerkleProofValidity<E> {
+    fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
+        let mut state = self.state.clone();
+        state.initialize_tree_hash_cache();
+        let proof = match state.compute_merkle_proof(self.merkle_proof.leaf_index) {
+            Ok(proof) => proof,
+            Err(_) => {
+                return Err(Error::FailedToParseTest(
+                    "Could not retrieve merkle proof".to_string(),
+                ))
+            }
+        };
+        let proof_len = proof.len();
+        let branch_len = self.merkle_proof.branch.len();
+        if proof_len != branch_len {
+            return Err(Error::NotEqual(format!(
+                "Branches not equal in length computed: {}, expected {}",
+                proof_len, branch_len
+            )));
+        }
+
+        for (i, proof_leaf) in proof.iter().enumerate().take(proof_len) {
+            let expected_leaf = self.merkle_proof.branch[i];
+            if *proof_leaf != expected_leaf {
+                return Err(Error::NotEqual(format!(
+                    "Leaves not equal in merke proof computed: {}, expected: {}",
+                    hex::encode(proof_leaf),
+                    hex::encode(expected_leaf)
+                )));
+            }
+        }
+
+        // Tree hash cache should still be initialized (not dropped).
+        assert!(state.tree_hash_cache().is_initialized());
+
+        Ok(())
+    }
+}

testing/ef_tests/src/cases/operations.rs

@@ -91,7 +91,6 @@ impl<E: EthSpec> Operation<E> for Attestation<E> {
         _: &Operations<E, Self>,
     ) -> Result<(), BlockProcessingError> {
         let mut ctxt = ConsensusContext::new(state.slot());
-        let proposer_index = ctxt.get_proposer_index(state, spec)?;
         match state {
             BeaconState::Base(_) => base::process_attestations(
                 state,
@@ -103,14 +102,9 @@ impl<E: EthSpec> Operation<E> for Attestation<E> {
             BeaconState::Altair(_)
             | BeaconState::Merge(_)
             | BeaconState::Capella(_)
-            | BeaconState::Eip4844(_) => altair::process_attestation(
-                state,
-                self,
-                0,
-                proposer_index,
-                VerifySignatures::True,
-                spec,
-            ),
+            | BeaconState::Eip4844(_) => {
+                altair::process_attestation(state, self, 0, &mut ctxt, VerifySignatures::True, spec)
+            }
         }
     }
 }

testing/ef_tests/src/handler.rs

@@ -624,6 +624,30 @@ impl<E: EthSpec + TypeName> Handler for GenesisInitializationHandler<E> {
     }
 }
 
+#[derive(Derivative)]
+#[derivative(Default(bound = ""))]
+pub struct MerkleProofValidityHandler<E>(PhantomData<E>);
+
+impl<E: EthSpec + TypeName> Handler for MerkleProofValidityHandler<E> {
+    type Case = cases::MerkleProofValidity<E>;
+
+    fn config_name() -> &'static str {
+        E::name()
+    }
+
+    fn runner_name() -> &'static str {
+        "light_client"
+    }
+
+    fn handler_name(&self) -> String {
+        "single_merkle_proof".into()
+    }
+
+    fn is_enabled_for_fork(&self, fork_name: ForkName) -> bool {
+        fork_name != ForkName::Base
+    }
+}
+
 #[derive(Derivative)]
 #[derivative(Default(bound = ""))]
 pub struct OperationsHandler<E, O>(PhantomData<(E, O)>);