Prepare proposer (#3043)

## Issue Addressed

Resolves #2936

## Proposed Changes

Adds functionality for calling [`validator/prepare_beacon_proposer`](https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Validator/prepareBeaconProposer) in advance.

There is a `BeaconChain::prepare_beacon_proposer` method which, which called, computes the proposer for the next slot. If that proposer has been registered via the `validator/prepare_beacon_proposer` API method, then the `beacon_chain.execution_layer` will be provided the `PayloadAttributes` for us in all future forkchoiceUpdated calls. An artificial forkchoiceUpdated call will be created 4s before each slot, when the head updates and when a validator updates their information.

Additionally, I added strict ordering for calls from the `BeaconChain` to the `ExecutionLayer`. I'm not certain the `ExecutionLayer` will always maintain this ordering, but it's a good start to have consistency from the `BeaconChain`. There are some deadlock opportunities introduced, they are documented in the code.

## Additional Info

- ~~Blocked on #2837~~

Co-authored-by: realbigsean <seananderson33@GMAIL.com>

beacon_node/execution_layer/src/test_utils/handle_rpc.rs

@@ -10,6 +10,8 @@ pub async fn handle_rpc<T: EthSpec>(
     body: JsonValue,
     ctx: Arc<Context<T>>,
 ) -> Result<JsonValue, String> {
+    *ctx.previous_request.lock() = Some(body.clone());
+
     let method = body
         .get("method")
         .and_then(JsonValue::as_str)

beacon_node/execution_layer/src/test_utils/mock_execution_layer.rs

@@ -124,15 +124,29 @@ impl<T: EthSpec> MockExecutionLayer<T> {
         let prev_randao = Hash256::from_low_u64_be(block_number);
         let finalized_block_hash = parent_hash;
 
+        // Insert a proposer to ensure the fork choice updated command works.
+        let slot = Slot::new(0);
+        let head_block_root = Hash256::repeat_byte(42);
+        let validator_index = 0;
+        self.el
+            .insert_proposer(
+                slot,
+                head_block_root,
+                validator_index,
+                PayloadAttributes {
+                    timestamp,
+                    prev_randao,
+                    suggested_fee_recipient: Address::repeat_byte(42),
+                },
+            )
+            .await;
+
         self.el
             .notify_forkchoice_updated(
                 parent_hash,
                 ExecutionBlockHash::zero(),
-                Some(PayloadAttributes {
-                    timestamp,
-                    prev_randao,
-                    suggested_fee_recipient: Address::repeat_byte(42),
-                }),
+                slot,
+                head_block_root,
             )
             .await
             .unwrap();
@@ -158,8 +172,16 @@ impl<T: EthSpec> MockExecutionLayer<T> {
         let status = self.el.notify_new_payload(&payload).await.unwrap();
         assert_eq!(status, PayloadStatus::Valid);
 
+        // Use junk values for slot/head-root to ensure there is no payload supplied.
+        let slot = Slot::new(0);
+        let head_block_root = Hash256::repeat_byte(13);
         self.el
-            .notify_forkchoice_updated(block_hash, ExecutionBlockHash::zero(), None)
+            .notify_forkchoice_updated(
+                block_hash,
+                ExecutionBlockHash::zero(),
+                slot,
+                head_block_root,
+            )
             .await
             .unwrap();
 

beacon_node/execution_layer/src/test_utils/mod.rs

@@ -65,6 +65,7 @@ impl<T: EthSpec> MockServer<T> {
             log: null_logger().unwrap(),
             last_echo_request: last_echo_request.clone(),
             execution_block_generator: RwLock::new(execution_block_generator),
+            previous_request: <_>::default(),
             preloaded_responses,
             static_new_payload_response: <_>::default(),
             _phantom: PhantomData,
@@ -120,6 +121,10 @@ impl<T: EthSpec> MockServer<T> {
         self.ctx.preloaded_responses.lock().push(response)
     }
 
+    pub fn take_previous_request(&self) -> Option<serde_json::Value> {
+        self.ctx.previous_request.lock().take()
+    }
+
     pub fn all_payloads_valid(&self) {
         let response = StaticNewPayloadResponse {
             status: PayloadStatusV1 {
@@ -241,6 +246,7 @@ pub struct Context<T: EthSpec> {
     pub last_echo_request: Arc<RwLock<Option<Bytes>>>,
     pub execution_block_generator: RwLock<ExecutionBlockGenerator<T>>,
     pub preloaded_responses: Arc<Mutex<Vec<serde_json::Value>>>,
+    pub previous_request: Arc<Mutex<Option<serde_json::Value>>>,
     pub static_new_payload_response: Arc<Mutex<Option<StaticNewPayloadResponse>>>,
     pub _phantom: PhantomData<T>,
 }