Update engine_api to Latest spec

beacon_node/beacon_chain/tests/payload_invalidation.rs

@@ -1007,9 +1007,7 @@ async fn payload_preparation() {
             .unwrap(),
         fee_recipient,
         None,
-    )
-    .downgrade_to_v1()
-    .unwrap();
+    );
     assert_eq!(rig.previous_payload_attributes(), payload_attributes);
 }
 

beacon_node/execution_layer/src/engine_api.rs

@@ -12,6 +12,7 @@ pub use types::{
     Address, EthSpec, ExecutionBlockHash, ExecutionPayload, ExecutionPayloadHeader, FixedVector,
     ForkName, Hash256, Uint256, VariableList, Withdrawal,
 };
+use types::{ExecutionPayloadCapella, ExecutionPayloadEip4844, ExecutionPayloadMerge};
 
 pub mod auth;
 pub mod http;
@@ -267,7 +268,7 @@ pub struct PayloadAttributes {
     #[superstruct(getter(copy))]
     pub suggested_fee_recipient: Address,
     #[superstruct(only(V2))]
-    pub withdrawals: Option<Vec<Withdrawal>>,
+    pub withdrawals: Vec<Withdrawal>,
 }
 
 impl PayloadAttributes {
@@ -277,31 +278,18 @@ impl PayloadAttributes {
         suggested_fee_recipient: Address,
         withdrawals: Option<Vec<Withdrawal>>,
     ) -> Self {
-        // this should always return the highest version
-        PayloadAttributes::V2(PayloadAttributesV2 {
-            timestamp,
-            prev_randao,
-            suggested_fee_recipient,
-            withdrawals,
-        })
-    }
-
-    pub fn downgrade_to_v1(self) -> Result<Self, Error> {
-        match self {
-            PayloadAttributes::V1(_) => Ok(self),
-            PayloadAttributes::V2(v2) => {
-                if v2.withdrawals.is_some() {
-                    return Err(Error::BadConversion(
-                        "Downgrading from PayloadAttributesV2 with non-null withdrawals"
-                            .to_string(),
-                    ));
-                }
-                Ok(PayloadAttributes::V1(PayloadAttributesV1 {
-                    timestamp: v2.timestamp,
-                    prev_randao: v2.prev_randao,
-                    suggested_fee_recipient: v2.suggested_fee_recipient,
-                }))
-            }
+        match withdrawals {
+            Some(withdrawals) => PayloadAttributes::V2(PayloadAttributesV2 {
+                timestamp,
+                prev_randao,
+                suggested_fee_recipient,
+                withdrawals,
+            }),
+            None => PayloadAttributes::V1(PayloadAttributesV1 {
+                timestamp,
+                prev_randao,
+                suggested_fee_recipient,
+            }),
         }
     }
 }
@@ -326,6 +314,39 @@ pub struct ProposeBlindedBlockResponse {
     pub validation_error: Option<String>,
 }
 
+#[superstruct(
+    variants(Merge, Capella, Eip4844),
+    variant_attributes(derive(Clone, Debug, PartialEq),),
+    cast_error(ty = "Error", expr = "Error::IncorrectStateVariant"),
+    partial_getter_error(ty = "Error", expr = "Error::IncorrectStateVariant")
+)]
+#[derive(Clone, Debug, PartialEq)]
+pub struct GetPayloadResponse<T: EthSpec> {
+    #[superstruct(only(Merge), partial_getter(rename = "execution_payload_merge"))]
+    pub execution_payload: ExecutionPayloadMerge<T>,
+    #[superstruct(only(Capella), partial_getter(rename = "execution_payload_capella"))]
+    pub execution_payload: ExecutionPayloadCapella<T>,
+    #[superstruct(only(Eip4844), partial_getter(rename = "execution_payload_eip4844"))]
+    pub execution_payload: ExecutionPayloadEip4844<T>,
+    pub block_value: Uint256,
+}
+
+impl<T: EthSpec> GetPayloadResponse<T> {
+    pub fn execution_payload(self) -> ExecutionPayload<T> {
+        match self {
+            GetPayloadResponse::Merge(response) => {
+                ExecutionPayload::Merge(response.execution_payload)
+            }
+            GetPayloadResponse::Capella(response) => {
+                ExecutionPayload::Capella(response.execution_payload)
+            }
+            GetPayloadResponse::Eip4844(response) => {
+                ExecutionPayload::Eip4844(response.execution_payload)
+            }
+        }
+    }
+}
+
 // This name is work in progress, it could
 // change when this method is actually proposed
 // but I'm writing this as it has been described

beacon_node/execution_layer/src/engine_api/http.rs

@@ -735,7 +735,7 @@ impl HttpJsonRpc {
         &self,
         execution_payload: ExecutionPayload<T>,
     ) -> Result<PayloadStatusV1, Error> {
-        let params = json!([JsonExecutionPayloadV1::try_from(execution_payload)?]);
+        let params = json!([JsonExecutionPayload::from(execution_payload)]);
 
         let response: JsonPayloadStatusV1 = self
             .rpc_request(
@@ -752,7 +752,7 @@ impl HttpJsonRpc {
         &self,
         execution_payload: ExecutionPayload<T>,
     ) -> Result<PayloadStatusV1, Error> {
-        let params = json!([JsonExecutionPayloadV2::try_from(execution_payload)?]);
+        let params = json!([JsonExecutionPayload::from(execution_payload)]);
 
         let response: JsonPayloadStatusV1 = self
             .rpc_request(
@@ -767,7 +767,6 @@ impl HttpJsonRpc {
 
     pub async fn get_payload_v1<T: EthSpec>(
         &self,
-        fork_name: ForkName,
         payload_id: PayloadId,
     ) -> Result<ExecutionPayload<T>, Error> {
         let params = json!([JsonPayloadIdRequest::from(payload_id)]);
@@ -780,25 +779,41 @@ impl HttpJsonRpc {
             )
             .await?;
 
-        JsonExecutionPayload::V1(payload_v1).try_into_execution_payload(fork_name)
+        Ok(JsonExecutionPayload::V1(payload_v1).into())
     }
 
     pub async fn get_payload_v2<T: EthSpec>(
         &self,
         fork_name: ForkName,
         payload_id: PayloadId,
-    ) -> Result<ExecutionPayload<T>, Error> {
+    ) -> Result<GetPayloadResponse<T>, Error> {
         let params = json!([JsonPayloadIdRequest::from(payload_id)]);
 
-        let response: JsonGetPayloadResponse<T> = self
-            .rpc_request(
-                ENGINE_GET_PAYLOAD_V2,
-                params,
-                ENGINE_GET_PAYLOAD_TIMEOUT * self.execution_timeout_multiplier,
-            )
-            .await?;
-
-        JsonExecutionPayload::V2(response.execution_payload).try_into_execution_payload(fork_name)
+        match fork_name {
+            ForkName::Merge => {
+                let response: JsonGetPayloadResponseV1<T> = self
+                    .rpc_request(
+                        ENGINE_GET_PAYLOAD_V2,
+                        params,
+                        ENGINE_GET_PAYLOAD_TIMEOUT * self.execution_timeout_multiplier,
+                    )
+                    .await?;
+                Ok(JsonGetPayloadResponse::V1(response).into())
+            }
+            ForkName::Capella => {
+                let response: JsonGetPayloadResponseV2<T> = self
+                    .rpc_request(
+                        ENGINE_GET_PAYLOAD_V2,
+                        params,
+                        ENGINE_GET_PAYLOAD_TIMEOUT * self.execution_timeout_multiplier,
+                    )
+                    .await?;
+                Ok(JsonGetPayloadResponse::V2(response).into())
+            }
+            ForkName::Base | ForkName::Altair | ForkName::Eip4844 => Err(
+                Error::UnsupportedForkVariant(format!("called get_payload_v2 with {}", fork_name)),
+            ),
+        }
     }
 
     pub async fn get_blobs_bundle_v1<T: EthSpec>(
@@ -935,9 +950,15 @@ impl HttpJsonRpc {
     ) -> Result<ExecutionPayload<T>, Error> {
         let supported_apis = self.get_cached_supported_apis().await?;
         if supported_apis.get_payload_v2 {
-            self.get_payload_v2(fork_name, payload_id).await
+            // TODO: modify this method to return GetPayloadResponse instead
+            //       of throwing away the `block_value` and returning only the
+            //       ExecutionPayload
+            Ok(self
+                .get_payload_v2(fork_name, payload_id)
+                .await?
+                .execution_payload())
         } else if supported_apis.new_payload_v1 {
-            self.get_payload_v1(fork_name, payload_id).await
+            self.get_payload_v1(payload_id).await
         } else {
             Err(Error::RequiredMethodUnsupported("engine_getPayload"))
         }
@@ -955,13 +976,8 @@ impl HttpJsonRpc {
             self.forkchoice_updated_v2(forkchoice_state, payload_attributes)
                 .await
         } else if supported_apis.forkchoice_updated_v1 {
-            self.forkchoice_updated_v1(
-                forkchoice_state,
-                payload_attributes
-                    .map(|pa| pa.downgrade_to_v1())
-                    .transpose()?,
-            )
-            .await
+            self.forkchoice_updated_v1(forkchoice_state, payload_attributes)
+                .await
         } else {
             Err(Error::RequiredMethodUnsupported("engine_forkchoiceUpdated"))
         }
@@ -976,9 +992,7 @@ mod test {
     use std::future::Future;
     use std::str::FromStr;
     use std::sync::Arc;
-    use types::{
-        ExecutionPayloadMerge, ForkName, MainnetEthSpec, Transactions, Unsigned, VariableList,
-    };
+    use types::{ExecutionPayloadMerge, MainnetEthSpec, Transactions, Unsigned, VariableList};
 
     struct Tester {
         server: MockServer<MainnetEthSpec>,
@@ -1318,9 +1332,7 @@ mod test {
         Tester::new(true)
             .assert_request_equals(
                 |client| async move {
-                    let _ = client
-                        .get_payload_v1::<MainnetEthSpec>(ForkName::Merge, [42; 8])
-                        .await;
+                    let _ = client.get_payload_v1::<MainnetEthSpec>([42; 8]).await;
                 },
                 json!({
                     "id": STATIC_ID,
@@ -1333,9 +1345,7 @@ mod test {
 
         Tester::new(false)
             .assert_auth_failure(|client| async move {
-                client
-                    .get_payload_v1::<MainnetEthSpec>(ForkName::Merge, [42; 8])
-                    .await
+                client.get_payload_v1::<MainnetEthSpec>([42; 8]).await
             })
             .await;
     }
@@ -1564,7 +1574,7 @@ mod test {
                 // engine_getPayloadV1 REQUEST validation
                 |client| async move {
                     let _ = client
-                        .get_payload_v1::<MainnetEthSpec>(ForkName::Merge,str_to_payload_id("0xa247243752eb10b4"))
+                        .get_payload_v1::<MainnetEthSpec>(str_to_payload_id("0xa247243752eb10b4"))
                         .await;
                 },
                 json!({
@@ -1599,7 +1609,7 @@ mod test {
                 })],
                 |client| async move {
                     let payload = client
-                        .get_payload_v1::<MainnetEthSpec>(ForkName::Merge,str_to_payload_id("0xa247243752eb10b4"))
+                        .get_payload_v1::<MainnetEthSpec>(str_to_payload_id("0xa247243752eb10b4"))
                         .await
                         .unwrap();