Update engine_api to latest version (#4223)

* Update Engine API to Latest

* Get Mock EE Working

* Fix Mock EE

* Update Engine API Again

* Rip out get_blobs_bundle Stuff

* Fix Test Harness

* Fix Clippy Complaints

* Fix Beacon Chain Tests

beacon_node/execution_layer/src/lib.rs

@@ -45,12 +45,12 @@ use types::beacon_block_body::KzgCommitments;
 use types::blob_sidecar::Blobs;
 use types::consts::deneb::BLOB_TX_TYPE;
 use types::transaction::{AccessTuple, BlobTransaction, EcdsaSignature, SignedBlobTransaction};
-use types::Withdrawals;
 use types::{AbstractExecPayload, BeaconStateError, ExecPayload, VersionedHash};
 use types::{
     BlindedPayload, BlockType, ChainSpec, Epoch, ExecutionBlockHash, ExecutionPayload,
     ExecutionPayloadCapella, ExecutionPayloadDeneb, ExecutionPayloadMerge, ForkName,
 };
+use types::{KzgProofs, Withdrawals};
 use types::{
     ProposerPreparationData, PublicKeyBytes, Signature, SignedBeaconBlock, Slot, Transaction,
     Uint256,
@@ -141,22 +141,53 @@ pub enum BlockProposalContents<T: EthSpec, Payload: AbstractExecPayload<T>> {
         block_value: Uint256,
         kzg_commitments: KzgCommitments<T>,
         blobs: Blobs<T>,
+        proofs: KzgProofs<T>,
     },
 }
 
+impl<E: EthSpec, Payload: AbstractExecPayload<E>> From<GetPayloadResponse<E>>
+    for BlockProposalContents<E, Payload>
+{
+    fn from(response: GetPayloadResponse<E>) -> Self {
+        let (execution_payload, block_value, maybe_bundle) = response.into();
+        match maybe_bundle {
+            Some(bundle) => Self::PayloadAndBlobs {
+                payload: execution_payload.into(),
+                block_value,
+                kzg_commitments: bundle.commitments,
+                blobs: bundle.blobs,
+                proofs: bundle.proofs,
+            },
+            None => Self::Payload {
+                payload: execution_payload.into(),
+                block_value,
+            },
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
 impl<T: EthSpec, Payload: AbstractExecPayload<T>> BlockProposalContents<T, Payload> {
-    pub fn deconstruct(self) -> (Payload, Option<KzgCommitments<T>>, Option<Blobs<T>>) {
+    pub fn deconstruct(
+        self,
+    ) -> (
+        Payload,
+        Option<KzgCommitments<T>>,
+        Option<Blobs<T>>,
+        Option<KzgProofs<T>>,
+    ) {
         match self {
             Self::Payload {
                 payload,
                 block_value: _,
-            } => (payload, None, None),
+            } => (payload, None, None, None),
             Self::PayloadAndBlobs {
                 payload,
                 block_value: _,
                 kzg_commitments,
                 blobs,
-            } => (payload, Some(kzg_commitments), Some(blobs)),
+                proofs,
+            } => (payload, Some(kzg_commitments), Some(blobs), Some(proofs)),
         }
     }
 
@@ -171,6 +202,7 @@ impl<T: EthSpec, Payload: AbstractExecPayload<T>> BlockProposalContents<T, Paylo
                 block_value: _,
                 kzg_commitments: _,
                 blobs: _,
+                proofs: _,
             } => payload,
         }
     }
@@ -185,6 +217,7 @@ impl<T: EthSpec, Payload: AbstractExecPayload<T>> BlockProposalContents<T, Paylo
                 block_value: _,
                 kzg_commitments: _,
                 blobs: _,
+                proofs: _,
             } => payload,
         }
     }
@@ -199,6 +232,7 @@ impl<T: EthSpec, Payload: AbstractExecPayload<T>> BlockProposalContents<T, Paylo
                 block_value,
                 kzg_commitments: _,
                 blobs: _,
+                proofs: _,
             } => block_value,
         }
     }
@@ -215,6 +249,7 @@ impl<T: EthSpec, Payload: AbstractExecPayload<T>> BlockProposalContents<T, Paylo
                 block_value: Uint256::zero(),
                 blobs: VariableList::default(),
                 kzg_commitments: VariableList::default(),
+                proofs: VariableList::default(),
             },
         })
     }
@@ -1116,25 +1151,7 @@ impl<T: EthSpec> ExecutionLayer<T> {
                     }
                 };
 
-                let blob_fut = async {
-                    match current_fork {
-                        ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => {
-                            None
-                        }
-                        ForkName::Deneb => {
-                            debug!(
-                                self.log(),
-                                "Issuing engine_getBlobsBundle";
-                                "suggested_fee_recipient" => ?payload_attributes.suggested_fee_recipient(),
-                                "prev_randao" => ?payload_attributes.prev_randao(),
-                                "timestamp" => payload_attributes.timestamp(),
-                                "parent_hash" => ?parent_hash,
-                            );
-                            Some(engine.api.get_blobs_bundle_v1::<T>(payload_id).await)
-                        }
-                    }
-                };
-                let payload_fut = async {
+                let payload_response = async {
                     debug!(
                         self.log(),
                         "Issuing engine_getPayload";
@@ -1144,45 +1161,30 @@ impl<T: EthSpec> ExecutionLayer<T> {
                         "parent_hash" => ?parent_hash,
                     );
                     engine.api.get_payload::<T>(current_fork, payload_id).await
-                };
-                let (blob, payload_response) = tokio::join!(blob_fut, payload_fut);
-                let (execution_payload, block_value) = payload_response.map(|payload_response| {
-                    if payload_response.execution_payload_ref().fee_recipient() != payload_attributes.suggested_fee_recipient() {
-                        error!(
-                            self.log(),
-                            "Inconsistent fee recipient";
-                            "msg" => "The fee recipient returned from the Execution Engine differs \
-                            from the suggested_fee_recipient set on the beacon node. This could \
-                            indicate that fees are being diverted to another address. Please \
-                            ensure that the value of suggested_fee_recipient is set correctly and \
-                            that the Execution Engine is trusted.",
-                            "fee_recipient" => ?payload_response.execution_payload_ref().fee_recipient(),
-                            "suggested_fee_recipient" => ?payload_attributes.suggested_fee_recipient(),
-                        );
-                    }
-                    if f(self, payload_response.execution_payload_ref()).is_some() {
-                        warn!(
-                            self.log(),
-                            "Duplicate payload cached, this might indicate redundant proposal \
-                                 attempts."
-                        );
-                    }
-                    payload_response.into()
-                })?;
-                if let Some(blob) = blob.transpose()? {
-                    // FIXME(sean) cache blobs
-                    Ok(BlockProposalContents::PayloadAndBlobs {
-                        payload: execution_payload.into(),
-                        block_value,
-                        blobs: blob.blobs,
-                        kzg_commitments: blob.kzgs,
-                    })
-                } else {
-                    Ok(BlockProposalContents::Payload {
-                        payload: execution_payload.into(),
-                        block_value,
-                    })
+                }.await?;
+
+                if payload_response.execution_payload_ref().fee_recipient() != payload_attributes.suggested_fee_recipient() {
+                    error!(
+                        self.log(),
+                        "Inconsistent fee recipient";
+                        "msg" => "The fee recipient returned from the Execution Engine differs \
+                        from the suggested_fee_recipient set on the beacon node. This could \
+                        indicate that fees are being diverted to another address. Please \
+                        ensure that the value of suggested_fee_recipient is set correctly and \
+                        that the Execution Engine is trusted.",
+                        "fee_recipient" => ?payload_response.execution_payload_ref().fee_recipient(),
+                        "suggested_fee_recipient" => ?payload_attributes.suggested_fee_recipient(),
+                    );
                 }
+                if f(self, payload_response.execution_payload_ref()).is_some() {
+                    warn!(
+                        self.log(),
+                        "Duplicate payload cached, this might indicate redundant proposal \
+                             attempts."
+                    );
+                }
+
+                Ok(payload_response.into())
             })
             .await
             .map_err(Box::new)