Engine API v1.0.0.alpha.6 + interop tests (#3024)

## Issue Addressed

NA

## Proposed Changes

This PR extends #3018 to address my review comments there and add automated integration tests with Geth (and other implementations, in the future).

I've also de-duplicated the "unused port" logic by creating an  `common/unused_port` crate.

## Additional Info

I'm not sure if we want to merge this PR, or update #3018 and merge that. I don't mind, I'm primarily opening this PR to make sure CI works.


Co-authored-by: Mark Mackey <mark@sigmaprime.io>

beacon_node/execution_layer/src/engine_api/json_structures.rs

@@ -247,47 +247,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 struct JsonPayloadStatusV1 {
+    pub status: JsonPayloadStatusV1Status,
     pub latest_valid_hash: Option<Hash256>,
     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(),
@@ -297,10 +310,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,
@@ -314,50 +327,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),
         }
     }
@@ -365,10 +351,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),
         }
     }