Add more tests

sigp · Mar 1, 2022 · b1ac426 · b1ac426
1 parent 357ff8b
commit b1ac426
Show file tree

Hide file tree

Showing 3 changed files with 103 additions and 0 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/beacon_node/beacon_chain/Cargo.toml b/beacon_node/beacon_chain/Cargo.toml
@@ -14,6 +14,7 @@ fork_from_env = [] # Initialise the harness chain spec from the FORK_NAME env va
 [dev-dependencies]
 maplit = "1.0.2"
 environment = { path = "../../lighthouse/environment" }
+serde_json = "1.0.58"
 
 [dependencies]
 merkle_proof = { path = "../../consensus/merkle_proof" }

diff --git a/beacon_node/beacon_chain/tests/payload_invalidation.rs b/beacon_node/beacon_chain/tests/payload_invalidation.rs
@@ -5,6 +5,9 @@ use beacon_chain::{
     BeaconChainError, BlockError, ExecutionPayloadError, HeadInfo, StateSkipConfig,
     WhenSlotSkipped, INVALID_JUSTIFIED_PAYLOAD_SHUTDOWN_REASON,
 };
+use execution_layer::{
+    json_structures::JsonPayloadAttributesV1, ExecutionLayer, PayloadAttributes,
+};
 use proto_array::ExecutionStatus;
 use task_executor::ShutdownReason;
 use types::*;
@@ -54,6 +57,10 @@ impl InvalidPayloadRig {
         self
     }
 
+    fn execution_layer(&self) -> ExecutionLayer {
+        self.harness.chain.execution_layer.clone().unwrap()
+    }
+
     fn block_hash(&self, block_root: Hash256) -> ExecutionBlockHash {
         self.harness
             .chain
@@ -85,6 +92,20 @@ impl InvalidPayloadRig {
         self.harness.chain.head_info().unwrap()
     }
 
+    fn previous_payload_attributes(&self) -> PayloadAttributes {
+        let mock_execution_layer = self.harness.mock_execution_layer.as_ref().unwrap();
+        let json = mock_execution_layer
+            .server
+            .take_previous_request()
+            .expect("no previous request");
+        dbg!(&json);
+        let params = json.get("params").expect("no params");
+        let payload_param_json = params.get(1).expect("no payload param");
+        let attributes: JsonPayloadAttributesV1 =
+            serde_json::from_value(payload_param_json.clone()).unwrap();
+        attributes.into()
+    }
+
     fn move_to_terminal_block(&self) {
         let mock_execution_layer = self.harness.mock_execution_layer.as_ref().unwrap();
         mock_execution_layer
@@ -599,3 +620,83 @@ fn invalid_after_optimistic_sync() {
     let head = rig.harness.chain.head_info().unwrap();
     assert_eq!(head.block_root, roots[1]);
 }
+
+#[test]
+fn payload_preparation() {
+    let mut rig = InvalidPayloadRig::new();
+    rig.move_to_terminal_block();
+    rig.import_block(Payload::Valid);
+
+    let el = rig.execution_layer();
+    let head = rig.harness.chain.head().unwrap();
+    let current_slot = rig.harness.chain.slot().unwrap();
+    assert_eq!(head.beacon_state.slot(), 1);
+    assert_eq!(current_slot, 1);
+
+    let next_slot = current_slot + 1;
+    let proposer = head
+        .beacon_state
+        .get_beacon_proposer_index(next_slot, &rig.harness.chain.spec)
+        .unwrap();
+
+    // Provide preparation data to the EL for `proposer`.
+    el.update_proposer_preparation_blocking(
+        Epoch::new(1),
+        &[ProposerPreparationData {
+            validator_index: proposer as u64,
+            fee_recipient: Address::zero(),
+        }],
+    )
+    .unwrap();
+
+    rig.harness
+        .chain
+        .prepare_beacon_proposer_blocking()
+        .unwrap();
+
+    let payload_attributes = PayloadAttributes {
+        timestamp: 0,
+        random: Hash256::zero(),
+        suggested_fee_recipient: Address::repeat_byte(42),
+    };
+    assert_eq!(rig.previous_payload_attributes(), payload_attributes);
+
+    /*
+    // Register `proposer` to propose at `next_slot`.
+    let timestamp = 42;
+    let random = Hash256::from_low_u64_be(timestamp);
+    let payload_attributes = PayloadAttributes {
+        timestamp,
+        random,
+        suggested_fee_recipient: Address::repeat_byte(42),
+    };
+    let already_known = el
+        .block_on_generic(|el| async {
+            el.insert_proposer(
+                next_slot,
+                head.beacon_block_root,
+                proposer as u64,
+                payload_attributes.clone(),
+            )
+            .await
+        })
+        .unwrap();
+    assert!(!already_known);
+
+    assert_eq!(rig.previous_payload_attributes(), payload_attributes);
+
+    // Insert the same proposer and ensure that it is flagged as "already known".
+    let already_known = el
+        .block_on_generic(|el| async {
+            el.insert_proposer(
+                next_slot,
+                head.beacon_block_root,
+                proposer as u64,
+                payload_attributes,
+            )
+            .await
+        })
+        .unwrap();
+    assert!(already_known);
+    */
+}