Merge remote-tracking branch 'origin/unstable' into tree-states

beacon_node/execution_layer/src/engine_api/http.rs

@@ -27,8 +27,8 @@ pub const ETH_GET_BLOCK_BY_HASH_TIMEOUT: Duration = Duration::from_secs(1);
 pub const ETH_SYNCING: &str = "eth_syncing";
 pub const ETH_SYNCING_TIMEOUT: Duration = Duration::from_millis(250);
 
-pub const ENGINE_EXECUTE_PAYLOAD_V1: &str = "engine_executePayloadV1";
-pub const ENGINE_EXECUTE_PAYLOAD_TIMEOUT: Duration = Duration::from_secs(2);
+pub const ENGINE_NEW_PAYLOAD_V1: &str = "engine_newPayloadV1";
+pub const ENGINE_NEW_PAYLOAD_TIMEOUT: Duration = Duration::from_secs(2);
 
 pub const ENGINE_GET_PAYLOAD_V1: &str = "engine_getPayloadV1";
 pub const ENGINE_GET_PAYLOAD_TIMEOUT: Duration = Duration::from_secs(2);
@@ -125,7 +125,7 @@ impl EngineApi for HttpJsonRpc {
 
     async fn get_block_by_hash<'a>(
         &self,
-        block_hash: Hash256,
+        block_hash: ExecutionBlockHash,
     ) -> Result<Option<ExecutionBlock>, Error> {
         let params = json!([block_hash, RETURN_FULL_TRANSACTION_OBJECTS]);
 
@@ -133,18 +133,14 @@ impl EngineApi for HttpJsonRpc {
             .await
     }
 
-    async fn execute_payload_v1<T: EthSpec>(
+    async fn new_payload_v1<T: EthSpec>(
         &self,
         execution_payload: ExecutionPayload<T>,
-    ) -> Result<ExecutePayloadResponse, Error> {
+    ) -> Result<PayloadStatusV1, Error> {
         let params = json!([JsonExecutionPayloadV1::from(execution_payload)]);
 
-        let response: JsonExecutePayloadV1Response = self
-            .rpc_request(
-                ENGINE_EXECUTE_PAYLOAD_V1,
-                params,
-                ENGINE_EXECUTE_PAYLOAD_TIMEOUT,
-            )
+        let response: JsonPayloadStatusV1 = self
+            .rpc_request(ENGINE_NEW_PAYLOAD_V1, params, ENGINE_NEW_PAYLOAD_TIMEOUT)
             .await?;
 
         Ok(response.into())
@@ -417,7 +413,9 @@ mod test {
         Tester::new()
             .assert_request_equals(
                 |client| async move {
-                    let _ = client.get_block_by_hash(Hash256::repeat_byte(1)).await;
+                    let _ = client
+                        .get_block_by_hash(ExecutionBlockHash::repeat_byte(1))
+                        .await;
                 },
                 json!({
                     "id": STATIC_ID,
@@ -437,9 +435,9 @@ mod test {
                     let _ = client
                         .forkchoice_updated_v1(
                             ForkChoiceState {
-                                head_block_hash: Hash256::repeat_byte(1),
-                                safe_block_hash: Hash256::repeat_byte(1),
-                                finalized_block_hash: Hash256::zero(),
+                                head_block_hash: ExecutionBlockHash::repeat_byte(1),
+                                safe_block_hash: ExecutionBlockHash::repeat_byte(1),
+                                finalized_block_hash: ExecutionBlockHash::zero(),
                             },
                             Some(PayloadAttributes {
                                 timestamp: 5,
@@ -486,16 +484,16 @@ mod test {
     }
 
     #[tokio::test]
-    async fn execute_payload_v1_request() {
+    async fn new_payload_v1_request() {
         Tester::new()
             .assert_request_equals(
                 |client| async move {
                     let _ = client
-                        .execute_payload_v1::<MainnetEthSpec>(ExecutionPayload {
-                            parent_hash: Hash256::repeat_byte(0),
+                        .new_payload_v1::<MainnetEthSpec>(ExecutionPayload {
+                            parent_hash: ExecutionBlockHash::repeat_byte(0),
                             fee_recipient: Address::repeat_byte(1),
                             state_root: Hash256::repeat_byte(1),
-                            receipt_root: Hash256::repeat_byte(0),
+                            receipts_root: Hash256::repeat_byte(0),
                             logs_bloom: vec![1; 256].into(),
                             random: Hash256::repeat_byte(1),
                             block_number: 0,
@@ -504,7 +502,7 @@ mod test {
                             timestamp: 42,
                             extra_data: vec![].into(),
                             base_fee_per_gas: Uint256::from(1),
-                            block_hash: Hash256::repeat_byte(1),
+                            block_hash: ExecutionBlockHash::repeat_byte(1),
                             transactions: vec![].into(),
                         })
                         .await;
@@ -512,7 +510,7 @@ mod test {
                 json!({
                     "id": STATIC_ID,
                     "jsonrpc": JSONRPC_VERSION,
-                    "method": ENGINE_EXECUTE_PAYLOAD_V1,
+                    "method": ENGINE_NEW_PAYLOAD_V1,
                     "params": [{
                         "parentHash": HASH_00,
                         "feeRecipient": ADDRESS_01,
@@ -542,9 +540,9 @@ mod test {
                     let _ = client
                         .forkchoice_updated_v1(
                             ForkChoiceState {
-                                head_block_hash: Hash256::repeat_byte(0),
-                                safe_block_hash: Hash256::repeat_byte(0),
-                                finalized_block_hash: Hash256::repeat_byte(1),
+                                head_block_hash: ExecutionBlockHash::repeat_byte(0),
+                                safe_block_hash: ExecutionBlockHash::repeat_byte(0),
+                                finalized_block_hash: ExecutionBlockHash::repeat_byte(1),
                             },
                             None,
                         )
@@ -592,9 +590,9 @@ mod test {
                     let _ = client
                         .forkchoice_updated_v1(
                             ForkChoiceState {
-                                head_block_hash: Hash256::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
-                                safe_block_hash: Hash256::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
-                                finalized_block_hash: Hash256::zero(),
+                                head_block_hash: ExecutionBlockHash::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
+                                safe_block_hash: ExecutionBlockHash::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
+                                finalized_block_hash: ExecutionBlockHash::zero(),
                             },
                             Some(PayloadAttributes {
                                 timestamp: 5,
@@ -627,7 +625,11 @@ mod test {
                     "id": STATIC_ID,
                     "jsonrpc": JSONRPC_VERSION,
                     "result": {
-                        "status": "SUCCESS",
+                        "payloadStatus": {
+                            "status": "VALID",
+                            "latestValidHash": HASH_00,
+                            "validationError": ""
+                        },
                         "payloadId": "0xa247243752eb10b4"
                     }
                 })],
@@ -635,9 +637,9 @@ mod test {
                     let response = client
                         .forkchoice_updated_v1(
                             ForkChoiceState {
-                                head_block_hash: Hash256::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
-                                safe_block_hash: Hash256::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
-                                finalized_block_hash: Hash256::zero(),
+                                head_block_hash: ExecutionBlockHash::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
+                                safe_block_hash: ExecutionBlockHash::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
+                                finalized_block_hash: ExecutionBlockHash::zero(),
                             },
                             Some(PayloadAttributes {
                                 timestamp: 5,
@@ -648,7 +650,11 @@ mod test {
                         .await
                         .unwrap();
                     assert_eq!(response, ForkchoiceUpdatedResponse {
-                        status: ForkchoiceUpdatedResponseStatus::Success,
+                        payload_status: PayloadStatusV1 {
+                            status: PayloadStatusV1Status::Valid,
+                            latest_valid_hash: Some(ExecutionBlockHash::zero()),
+                            validation_error: Some(String::new()),
+                        },
                         payload_id:
                             Some(str_to_payload_id("0xa247243752eb10b4")),
                     });
@@ -683,12 +689,12 @@ mod test {
                         "logsBloom": LOGS_BLOOM_00,
                         "random": HASH_00,
                         "blockNumber":"0x1",
-                        "gasLimit":"0x1c9c380",
+                        "gasLimit":"0x1c95111",
                         "gasUsed":"0x0",
                         "timestamp":"0x5",
                         "extraData":"0x",
                         "baseFeePerGas":"0x7",
-                        "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858",
+                        "blockHash":"0x6359b8381a370e2f54072a5784ddd78b6ed024991558c511d4452eb4f6ac898c",
                         "transactions":[]
                     }
                 })],
@@ -699,19 +705,19 @@ mod test {
                         .unwrap();
 
                     let expected = ExecutionPayload {
-                            parent_hash: Hash256::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
+                            parent_hash: ExecutionBlockHash::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
                             fee_recipient: Address::from_str("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b").unwrap(),
                             state_root: Hash256::from_str("0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45").unwrap(),
-                            receipt_root: Hash256::from_str("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap(),
+                            receipts_root: Hash256::from_str("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap(),
                             logs_bloom: vec![0; 256].into(),
                             random: Hash256::zero(),
                             block_number: 1,
-                            gas_limit: u64::from_str_radix("1c9c380",16).unwrap(),
+                            gas_limit: u64::from_str_radix("1c95111",16).unwrap(),
                             gas_used: 0,
                             timestamp: 5,
                             extra_data: vec![].into(),
                             base_fee_per_gas: Uint256::from(7),
-                            block_hash: Hash256::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
+                            block_hash: ExecutionBlockHash::from_str("0x6359b8381a370e2f54072a5784ddd78b6ed024991558c511d4452eb4f6ac898c").unwrap(),
                             transactions: vec![].into(),
                         };
 
@@ -720,14 +726,14 @@ mod test {
             )
             .await
             .assert_request_equals(
-                // engine_executePayloadV1 REQUEST validation
+                // engine_newPayloadV1 REQUEST validation
                 |client| async move {
                     let _ = client
-                        .execute_payload_v1::<MainnetEthSpec>(ExecutionPayload {
-                            parent_hash: Hash256::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
+                        .new_payload_v1::<MainnetEthSpec>(ExecutionPayload {
+                            parent_hash: ExecutionBlockHash::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
                             fee_recipient: Address::from_str("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b").unwrap(),
                             state_root: Hash256::from_str("0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45").unwrap(),
-                            receipt_root: Hash256::from_str("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap(),
+                            receipts_root: Hash256::from_str("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap(),
                             logs_bloom: vec![0; 256].into(),
                             random: Hash256::zero(),
                             block_number: 1,
@@ -736,7 +742,7 @@ mod test {
                             timestamp: 5,
                             extra_data: vec![].into(),
                             base_fee_per_gas: Uint256::from(7),
-                            block_hash: Hash256::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
+                            block_hash: ExecutionBlockHash::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
                             transactions: vec![].into(),
                         })
                         .await;
@@ -744,7 +750,7 @@ mod test {
                 json!({
                     "id": STATIC_ID,
                     "jsonrpc": JSONRPC_VERSION,
-                    "method": ENGINE_EXECUTE_PAYLOAD_V1,
+                    "method": ENGINE_NEW_PAYLOAD_V1,
                     "params": [{
                         "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a",
                         "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
@@ -765,26 +771,27 @@ mod test {
             )
             .await
             .with_preloaded_responses(
-                // engine_executePayloadV1 RESPONSE validation
+                // engine_newPayloadV1 RESPONSE validation
                 vec![json!({
                     "jsonrpc": JSONRPC_VERSION,
                     "id": STATIC_ID,
                     "result":{
                         "status":"VALID",
-                        "latestValidHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858"
+                        "latestValidHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858",
+                        "validationError":"",
                     }
                 })],
                 |client| async move {
                     let response = client
-                        .execute_payload_v1::<MainnetEthSpec>(ExecutionPayload::default())
+                        .new_payload_v1::<MainnetEthSpec>(ExecutionPayload::default())
                         .await
                         .unwrap();
 
                     assert_eq!(response,
-                        ExecutePayloadResponse {
-                            status: ExecutePayloadResponseStatus::Valid,
-                            latest_valid_hash: Some(Hash256::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap()),
-                            validation_error: None
+                               PayloadStatusV1 {
+                            status: PayloadStatusV1Status::Valid,
+                            latest_valid_hash: Some(ExecutionBlockHash::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap()),
+                            validation_error: Some(String::new()),
                         }
                     );
                 },
@@ -796,9 +803,9 @@ mod test {
                     let _ = client
                         .forkchoice_updated_v1(
                             ForkChoiceState {
-                                head_block_hash: Hash256::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
-                                safe_block_hash: Hash256::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
-                                finalized_block_hash: Hash256::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
+                                head_block_hash: ExecutionBlockHash::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
+                                safe_block_hash: ExecutionBlockHash::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
+                                finalized_block_hash: ExecutionBlockHash::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
                             },
                             None,
                         )
@@ -819,14 +826,15 @@ mod test {
             .await
             .with_preloaded_responses(
                 // engine_forkchoiceUpdatedV1 RESPONSE validation
-                //
-                // Note: this test was modified to provide `null` rather than `0x`. The geth vectors
-                // are invalid.
                 vec![json!({
                     "jsonrpc": JSONRPC_VERSION,
                     "id": STATIC_ID,
                     "result": {
-                        "status":"SUCCESS",
+                        "payloadStatus": {
+                            "status": "VALID",
+                            "latestValidHash": HASH_00,
+                            "validationError": ""
+                        },
                         "payloadId": JSON_NULL,
                     }
                 })],
@@ -834,16 +842,20 @@ mod test {
                     let response = client
                         .forkchoice_updated_v1(
                             ForkChoiceState {
-                                head_block_hash: Hash256::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
-                                safe_block_hash: Hash256::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
-                                finalized_block_hash: Hash256::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
+                                head_block_hash: ExecutionBlockHash::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
+                                safe_block_hash: ExecutionBlockHash::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
+                                finalized_block_hash: ExecutionBlockHash::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
                             },
                             None,
                         )
                         .await
                         .unwrap();
                     assert_eq!(response, ForkchoiceUpdatedResponse {
-                        status: ForkchoiceUpdatedResponseStatus::Success,
+                        payload_status: PayloadStatusV1 {
+                            status: PayloadStatusV1Status::Valid,
+                            latest_valid_hash: Some(ExecutionBlockHash::zero()),
+                            validation_error: Some(String::new()),
+                        },
                         payload_id: None,
                     });
                 },

beacon_node/execution_layer/src/engine_api/json_structures.rs

@@ -1,7 +1,7 @@
 use super::*;
 use serde::{Deserialize, Serialize};
 use ssz_types::FixedVector;
-use types::{EthSpec, Transaction, Unsigned, VariableList};
+use types::{EthSpec, ExecutionBlockHash, Transaction, Unsigned, VariableList};
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -59,7 +59,7 @@ pub struct JsonPayloadIdResponse {
 #[derive(Debug, PartialEq, Default, Serialize, Deserialize)]
 #[serde(bound = "T: EthSpec", rename_all = "camelCase")]
 pub struct JsonExecutionPayloadV1<T: EthSpec> {
-    pub parent_hash: Hash256,
+    pub parent_hash: ExecutionBlockHash,
     pub fee_recipient: Address,
     pub state_root: Hash256,
     pub receipts_root: Hash256,
@@ -77,7 +77,7 @@ pub struct JsonExecutionPayloadV1<T: EthSpec> {
     #[serde(with = "ssz_types::serde_utils::hex_var_list")]
     pub extra_data: VariableList<u8, T::MaxExtraDataBytes>,
     pub base_fee_per_gas: Uint256,
-    pub block_hash: Hash256,
+    pub block_hash: ExecutionBlockHash,
     #[serde(with = "serde_transactions")]
     pub transactions:
         VariableList<Transaction<T::MaxBytesPerTransaction>, T::MaxTransactionsPerPayload>,
@@ -90,7 +90,7 @@ impl<T: EthSpec> From<ExecutionPayload<T>> for JsonExecutionPayloadV1<T> {
             parent_hash,
             fee_recipient,
             state_root,
-            receipt_root,
+            receipts_root,
             logs_bloom,
             random,
             block_number,
@@ -107,7 +107,7 @@ impl<T: EthSpec> From<ExecutionPayload<T>> for JsonExecutionPayloadV1<T> {
             parent_hash,
             fee_recipient,
             state_root,
-            receipts_root: receipt_root,
+            receipts_root,
             logs_bloom,
             random,
             block_number,
@@ -146,7 +146,7 @@ impl<T: EthSpec> From<JsonExecutionPayloadV1<T>> for ExecutionPayload<T> {
             parent_hash,
             fee_recipient,
             state_root,
-            receipt_root: receipts_root,
+            receipts_root,
             logs_bloom,
             random,
             block_number,
@@ -207,9 +207,9 @@ impl From<JsonPayloadAttributesV1> for PayloadAttributes {
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct JsonForkChoiceStateV1 {
-    pub head_block_hash: Hash256,
-    pub safe_block_hash: Hash256,
-    pub finalized_block_hash: Hash256,
+    pub head_block_hash: ExecutionBlockHash,
+    pub safe_block_hash: ExecutionBlockHash,
+    pub finalized_block_hash: ExecutionBlockHash,
 }
 
 impl From<ForkChoiceState> for JsonForkChoiceStateV1 {
@@ -248,47 +248,60 @@ impl From<JsonForkChoiceStateV1> for ForkChoiceState {
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-pub enum JsonExecutePayloadV1ResponseStatus {
+pub enum JsonPayloadStatusV1Status {
     Valid,
     Invalid,
     Syncing,
+    Accepted,
+    InvalidBlockHash,
+    InvalidTerminalBlock,
 }
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct JsonExecutePayloadV1Response {
-    pub status: JsonExecutePayloadV1ResponseStatus,
-    pub latest_valid_hash: Option<Hash256>,
+pub struct JsonPayloadStatusV1 {
+    pub status: JsonPayloadStatusV1Status,
+    pub latest_valid_hash: Option<ExecutionBlockHash>,
     pub validation_error: Option<String>,
 }
 
-impl From<ExecutePayloadResponseStatus> for JsonExecutePayloadV1ResponseStatus {
-    fn from(e: ExecutePayloadResponseStatus) -> Self {
+impl From<PayloadStatusV1Status> for JsonPayloadStatusV1Status {
+    fn from(e: PayloadStatusV1Status) -> Self {
         match e {
-            ExecutePayloadResponseStatus::Valid => JsonExecutePayloadV1ResponseStatus::Valid,
-            ExecutePayloadResponseStatus::Invalid => JsonExecutePayloadV1ResponseStatus::Invalid,
-            ExecutePayloadResponseStatus::Syncing => JsonExecutePayloadV1ResponseStatus::Syncing,
+            PayloadStatusV1Status::Valid => JsonPayloadStatusV1Status::Valid,
+            PayloadStatusV1Status::Invalid => JsonPayloadStatusV1Status::Invalid,
+            PayloadStatusV1Status::Syncing => JsonPayloadStatusV1Status::Syncing,
+            PayloadStatusV1Status::Accepted => JsonPayloadStatusV1Status::Accepted,
+            PayloadStatusV1Status::InvalidBlockHash => JsonPayloadStatusV1Status::InvalidBlockHash,
+            PayloadStatusV1Status::InvalidTerminalBlock => {
+                JsonPayloadStatusV1Status::InvalidTerminalBlock
+            }
         }
     }
 }
-impl From<JsonExecutePayloadV1ResponseStatus> for ExecutePayloadResponseStatus {
-    fn from(j: JsonExecutePayloadV1ResponseStatus) -> Self {
+impl From<JsonPayloadStatusV1Status> for PayloadStatusV1Status {
+    fn from(j: JsonPayloadStatusV1Status) -> Self {
         match j {
-            JsonExecutePayloadV1ResponseStatus::Valid => ExecutePayloadResponseStatus::Valid,
-            JsonExecutePayloadV1ResponseStatus::Invalid => ExecutePayloadResponseStatus::Invalid,
-            JsonExecutePayloadV1ResponseStatus::Syncing => ExecutePayloadResponseStatus::Syncing,
+            JsonPayloadStatusV1Status::Valid => PayloadStatusV1Status::Valid,
+            JsonPayloadStatusV1Status::Invalid => PayloadStatusV1Status::Invalid,
+            JsonPayloadStatusV1Status::Syncing => PayloadStatusV1Status::Syncing,
+            JsonPayloadStatusV1Status::Accepted => PayloadStatusV1Status::Accepted,
+            JsonPayloadStatusV1Status::InvalidBlockHash => PayloadStatusV1Status::InvalidBlockHash,
+            JsonPayloadStatusV1Status::InvalidTerminalBlock => {
+                PayloadStatusV1Status::InvalidTerminalBlock
+            }
         }
     }
 }
 
-impl From<ExecutePayloadResponse> for JsonExecutePayloadV1Response {
-    fn from(e: ExecutePayloadResponse) -> Self {
+impl From<PayloadStatusV1> for JsonPayloadStatusV1 {
+    fn from(p: PayloadStatusV1) -> Self {
         // Use this verbose deconstruction pattern to ensure no field is left unused.
-        let ExecutePayloadResponse {
+        let PayloadStatusV1 {
             status,
             latest_valid_hash,
             validation_error,
-        } = e;
+        } = p;
 
         Self {
             status: status.into(),
@@ -298,10 +311,10 @@ impl From<ExecutePayloadResponse> for JsonExecutePayloadV1Response {
     }
 }
 
-impl From<JsonExecutePayloadV1Response> for ExecutePayloadResponse {
-    fn from(j: JsonExecutePayloadV1Response) -> Self {
+impl From<JsonPayloadStatusV1> for PayloadStatusV1 {
+    fn from(j: JsonPayloadStatusV1) -> Self {
         // Use this verbose deconstruction pattern to ensure no field is left unused.
-        let JsonExecutePayloadV1Response {
+        let JsonPayloadStatusV1 {
             status,
             latest_valid_hash,
             validation_error,
@@ -315,50 +328,23 @@ impl From<JsonExecutePayloadV1Response> for ExecutePayloadResponse {
     }
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-pub enum JsonForkchoiceUpdatedV1ResponseStatus {
-    Success,
-    Syncing,
-}
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct JsonForkchoiceUpdatedV1Response {
-    pub status: JsonForkchoiceUpdatedV1ResponseStatus,
+    pub payload_status: JsonPayloadStatusV1,
     pub payload_id: Option<TransparentJsonPayloadId>,
 }
 
-impl From<JsonForkchoiceUpdatedV1ResponseStatus> for ForkchoiceUpdatedResponseStatus {
-    fn from(j: JsonForkchoiceUpdatedV1ResponseStatus) -> Self {
-        match j {
-            JsonForkchoiceUpdatedV1ResponseStatus::Success => {
-                ForkchoiceUpdatedResponseStatus::Success
-            }
-            JsonForkchoiceUpdatedV1ResponseStatus::Syncing => {
-                ForkchoiceUpdatedResponseStatus::Syncing
-            }
-        }
-    }
-}
-impl From<ForkchoiceUpdatedResponseStatus> for JsonForkchoiceUpdatedV1ResponseStatus {
-    fn from(f: ForkchoiceUpdatedResponseStatus) -> Self {
-        match f {
-            ForkchoiceUpdatedResponseStatus::Success => {
-                JsonForkchoiceUpdatedV1ResponseStatus::Success
-            }
-            ForkchoiceUpdatedResponseStatus::Syncing => {
-                JsonForkchoiceUpdatedV1ResponseStatus::Syncing
-            }
-        }
-    }
-}
 impl From<JsonForkchoiceUpdatedV1Response> for ForkchoiceUpdatedResponse {
     fn from(j: JsonForkchoiceUpdatedV1Response) -> Self {
         // Use this verbose deconstruction pattern to ensure no field is left unused.
-        let JsonForkchoiceUpdatedV1Response { status, payload_id } = j;
+        let JsonForkchoiceUpdatedV1Response {
+            payload_status: status,
+            payload_id,
+        } = j;
 
         Self {
-            status: status.into(),
+            payload_status: status.into(),
             payload_id: payload_id.map(Into::into),
         }
     }
@@ -366,10 +352,13 @@ impl From<JsonForkchoiceUpdatedV1Response> for ForkchoiceUpdatedResponse {
 impl From<ForkchoiceUpdatedResponse> for JsonForkchoiceUpdatedV1Response {
     fn from(f: ForkchoiceUpdatedResponse) -> Self {
         // Use this verbose deconstruction pattern to ensure no field is left unused.
-        let ForkchoiceUpdatedResponse { status, payload_id } = f;
+        let ForkchoiceUpdatedResponse {
+            payload_status: status,
+            payload_id,
+        } = f;
 
         Self {
-            status: status.into(),
+            payload_status: status.into(),
             payload_id: payload_id.map(Into::into),
         }
     }