beacon: consensus: implement engine api getBlobs

beacon_node/execution_layer/src/engine_api.rs

@@ -7,9 +7,10 @@ use serde::{Deserialize, Serialize};
 use strum::IntoStaticStr;
 pub use types::{
     Address, EthSpec, ExecutionBlockHash, ExecutionPayload, ExecutionPayloadHeader, FixedVector,
-    Hash256, Uint256, VariableList,
+    Hash256, Uint256, VariableList, kzg_proof::KzgProof, kzg_commitment::KzgCommitment, blob::Blob,
 };
 
+
 pub mod auth;
 pub mod http;
 pub mod json_structures;

beacon_node/execution_layer/src/engine_api/http.rs

@@ -3,13 +3,14 @@
 use super::*;
 use crate::auth::Auth;
 use crate::json_structures::*;
+use eth2::lighthouse::Eth1Block;
 use reqwest::header::CONTENT_TYPE;
 use sensitive_url::SensitiveUrl;
 use serde::de::DeserializeOwned;
 use serde_json::json;
 
 use std::time::Duration;
-use types::EthSpec;
+use types::{EthSpec, FullPayload, execution_payload::BlobsBundle};
 
 pub use deposit_log::{DepositLog, Log};
 pub use reqwest::Client;
@@ -34,6 +35,9 @@ pub const ENGINE_NEW_PAYLOAD_TIMEOUT: Duration = Duration::from_secs(8);
 pub const ENGINE_GET_PAYLOAD_V1: &str = "engine_getPayloadV1";
 pub const ENGINE_GET_PAYLOAD_TIMEOUT: Duration = Duration::from_secs(2);
 
+pub const ENGINE_GET_BLOBS_BUNDLE_V1: &str = "engine_getBlobsBundleV1";
+pub const ENGINE_GET_BLOBS_BUNDLE_TIMEOUT: Duration = Duration::from_secs(2);
+
 pub const ENGINE_FORKCHOICE_UPDATED_V1: &str = "engine_forkchoiceUpdatedV1";
 pub const ENGINE_FORKCHOICE_UPDATED_TIMEOUT: Duration = Duration::from_secs(8);
 
@@ -664,6 +668,32 @@ impl HttpJsonRpc {
         Ok(response.into())
     }
 
+    pub async fn get_blobs_bundle_v1<T: EthSpec>(
+        &self,
+        payload_id: PayloadId,
+    ) -> Result<BlobsBundle<T>, Error> {
+        let params = json!([JsonPayloadIdRequest::from(payload_id)]);
+
+        let response: JsonBlobBundlesV1<T> = self
+            .rpc_request(ENGINE_GET_BLOBS_BUNDLE_V1, params, ENGINE_GET_BLOBS_BUNDLE_TIMEOUT)
+            .await?;
+
+        Ok(response.into())
+    }
+
+    pub async fn get_full_payload<T: EthSpec>(
+        &self,
+        payload_id: PayloadId,
+    ) -> Result<FullPayload<T>, Error> {
+        let payload = self.get_payload_v1(payload_id).await;
+        let blobs = self.get_blobs_bundle_v1(payload_id).await;
+
+        Ok(FullPayload{
+            execution_payload: payload?,
+            blobs_bundle: blobs?.into(),
+        })
+    }
+
     pub async fn forkchoice_updated_v1(
         &self,
         forkchoice_state: ForkChoiceState,

beacon_node/execution_layer/src/engine_api/json_structures.rs

@@ -1,6 +1,6 @@
 use super::*;
 use serde::{Deserialize, Serialize};
-use types::{EthSpec, ExecutionBlockHash, FixedVector, Transaction, Unsigned, VariableList};
+use types::{EthSpec, ExecutionBlockHash, FixedVector, Transaction, Unsigned, VariableList, execution_payload::BlobsBundle};
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -269,6 +269,54 @@ impl From<JsonPayloadAttributesV1> for PayloadAttributes {
     }
 }
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(bound = "T: EthSpec", rename_all = "camelCase")]
+pub struct JsonBlobBundlesV1<T: EthSpec> {
+    pub block_hash: Hash256,
+    pub kzgs: Vec<KzgCommitment>,
+    pub blobs: Vec<Blob<T>>,
+    pub aggregated_proof: KzgProof,
+}
+
+impl <T: EthSpec> From<BlobsBundle<T>> for JsonBlobBundlesV1<T> {
+    fn from(p: BlobsBundle<T>) -> Self {
+        // Use this verbose deconstruction pattern to ensure no field is left unused.
+        let BlobsBundle {
+            block_hash,
+            aggregated_proof,
+            blobs,
+            kzgs,
+        } = p;
+
+        Self {
+            block_hash,
+            aggregated_proof,
+            blobs,
+            kzgs,
+        }
+    }
+}
+
+impl <T: EthSpec> From<JsonBlobBundlesV1<T>> for BlobsBundle<T> {
+    fn from(j: JsonBlobBundlesV1<T>) -> Self {
+        // Use this verbose deconstruction pattern to ensure no field is left unused.
+        let JsonBlobBundlesV1 {
+            block_hash,
+            aggregated_proof,
+            blobs,
+            kzgs,
+        } = j;
+
+        Self {
+            block_hash,
+            aggregated_proof,
+            blobs,
+            kzgs,
+        }
+    }
+}
+
+
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct JsonForkChoiceStateV1 {

beacon_node/execution_layer/src/lib.rs

@@ -835,10 +835,10 @@ impl<T: EthSpec> ExecutionLayer<T> {
 
                 engine
                     .api
-                    .get_payload_v1::<T>(payload_id)
+                    .get_full_payload::<T>(payload_id)
                     .await
                     .map(|full_payload| {
-                        if full_payload.fee_recipient != suggested_fee_recipient {
+                        if full_payload.execution_payload.fee_recipient != suggested_fee_recipient {
                             error!(
                                 self.log(),
                                 "Inconsistent fee recipient";
@@ -847,11 +847,11 @@ impl<T: EthSpec> ExecutionLayer<T> {
                                 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" => ?full_payload.fee_recipient,
+                                "fee_recipient" => ?full_payload.execution_payload.fee_recipient,
                                 "suggested_fee_recipient" => ?suggested_fee_recipient,
                             );
                         }
-                        if f(self, &full_payload).is_some() {
+                        if f(self, &full_payload.execution_payload).is_some() {
                             warn!(
                                 self.log(),
                                 "Duplicate payload cached, this might indicate redundant proposal \