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

beacon_node/execution_layer/src/engine_api/auth.rs

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use jsonwebtoken::{encode, get_current_timestamp, Algorithm, EncodingKey, Header};
 use rand::Rng;
 use serde::{Deserialize, Serialize};
@@ -13,6 +15,7 @@ pub const JWT_SECRET_LENGTH: usize = 32;
 pub enum Error {
     JWT(jsonwebtoken::errors::Error),
     InvalidToken,
+    InvalidKey(String),
 }
 
 impl From<jsonwebtoken::errors::Error> for Error {
@@ -22,7 +25,7 @@ impl From<jsonwebtoken::errors::Error> for Error {
 }
 
 /// Provides wrapper around `[u8; JWT_SECRET_LENGTH]` that implements `Zeroize`.
-#[derive(Zeroize)]
+#[derive(Zeroize, Clone)]
 #[zeroize(drop)]
 pub struct JwtKey([u8; JWT_SECRET_LENGTH as usize]);
 
@@ -57,6 +60,14 @@ impl JwtKey {
     }
 }
 
+pub fn strip_prefix(s: &str) -> &str {
+    if let Some(stripped) = s.strip_prefix("0x") {
+        stripped
+    } else {
+        s
+    }
+}
+
 /// Contains the JWT secret and claims parameters.
 pub struct Auth {
     key: EncodingKey,
@@ -73,6 +84,28 @@ impl Auth {
         }
     }
 
+    /// Create a new `Auth` struct given the path to the file containing the hex
+    /// encoded jwt key.
+    pub fn new_with_path(
+        jwt_path: PathBuf,
+        id: Option<String>,
+        clv: Option<String>,
+    ) -> Result<Self, Error> {
+        std::fs::read_to_string(&jwt_path)
+            .map_err(|e| {
+                Error::InvalidKey(format!(
+                    "Failed to read JWT secret file {:?}, error: {:?}",
+                    jwt_path, e
+                ))
+            })
+            .and_then(|ref s| {
+                let secret_bytes = hex::decode(strip_prefix(s.trim_end()))
+                    .map_err(|e| Error::InvalidKey(format!("Invalid hex string: {:?}", e)))?;
+                let secret = JwtKey::from_slice(&secret_bytes).map_err(Error::InvalidKey)?;
+                Ok(Self::new(secret, id, clv))
+            })
+    }
+
     /// Generate a JWT token with `claims.iat` set to current time.
     pub fn generate_token(&self) -> Result<String, Error> {
         let claims = self.generate_claims_at_timestamp();
@@ -126,12 +159,12 @@ pub struct Claims {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::JWT_SECRET;
+    use crate::test_utils::DEFAULT_JWT_SECRET;
 
     #[test]
     fn test_roundtrip() {
         let auth = Auth::new(
-            JwtKey::from_slice(&JWT_SECRET).unwrap(),
+            JwtKey::from_slice(&DEFAULT_JWT_SECRET).unwrap(),
             Some("42".into()),
             Some("Lighthouse".into()),
         );
@@ -139,7 +172,7 @@ mod tests {
         let token = auth.generate_token_with_claims(&claims).unwrap();
 
         assert_eq!(
-            Auth::validate_token(&token, &JwtKey::from_slice(&JWT_SECRET).unwrap())
+            Auth::validate_token(&token, &JwtKey::from_slice(&DEFAULT_JWT_SECRET).unwrap())
                 .unwrap()
                 .claims,
             claims

beacon_node/execution_layer/src/engine_api/http.rs

@@ -3,15 +3,15 @@
 use super::*;
 use crate::auth::Auth;
 use crate::json_structures::*;
-use eth1::http::EIP155_ERROR_STR;
 use reqwest::header::CONTENT_TYPE;
 use sensitive_url::SensitiveUrl;
 use serde::de::DeserializeOwned;
 use serde_json::json;
-use std::marker::PhantomData;
-use std::time::Duration;
-use types::{BlindedPayload, EthSpec, ExecutionPayloadHeader, SignedBeaconBlock};
 
+use std::time::Duration;
+use types::EthSpec;
+
+pub use deposit_log::{DepositLog, Log};
 pub use reqwest::Client;
 
 const STATIC_ID: u32 = 1;
@@ -26,42 +26,507 @@ pub const ETH_GET_BLOCK_BY_HASH: &str = "eth_getBlockByHash";
 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 ETH_SYNCING_TIMEOUT: Duration = Duration::from_secs(1);
 
 pub const ENGINE_NEW_PAYLOAD_V1: &str = "engine_newPayloadV1";
-pub const ENGINE_NEW_PAYLOAD_TIMEOUT: Duration = Duration::from_secs(6);
+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_FORKCHOICE_UPDATED_V1: &str = "engine_forkchoiceUpdatedV1";
-pub const ENGINE_FORKCHOICE_UPDATED_TIMEOUT: Duration = Duration::from_secs(6);
+pub const ENGINE_FORKCHOICE_UPDATED_TIMEOUT: Duration = Duration::from_secs(8);
 
 pub const ENGINE_EXCHANGE_TRANSITION_CONFIGURATION_V1: &str =
     "engine_exchangeTransitionConfigurationV1";
-pub const ENGINE_EXCHANGE_TRANSITION_CONFIGURATION_V1_TIMEOUT: Duration =
-    Duration::from_millis(500);
+pub const ENGINE_EXCHANGE_TRANSITION_CONFIGURATION_V1_TIMEOUT: Duration = Duration::from_secs(1);
 
-pub const BUILDER_GET_PAYLOAD_HEADER_V1: &str = "builder_getPayloadHeaderV1";
-pub const BUILDER_GET_PAYLOAD_HEADER_TIMEOUT: Duration = Duration::from_secs(2);
+/// This error is returned during a `chainId` call by Geth.
+pub const EIP155_ERROR_STR: &str = "chain not synced beyond EIP-155 replay-protection fork block";
 
-pub const BUILDER_PROPOSE_BLINDED_BLOCK_V1: &str = "builder_proposeBlindedBlockV1";
-pub const BUILDER_PROPOSE_BLINDED_BLOCK_TIMEOUT: Duration = Duration::from_secs(2);
+/// Contains methods to convert arbitary bytes to an ETH2 deposit contract object.
+pub mod deposit_log {
+    use ssz::Decode;
+    use state_processing::per_block_processing::signature_sets::deposit_pubkey_signature_message;
+    use types::{ChainSpec, DepositData, Hash256, PublicKeyBytes, SignatureBytes};
 
-pub struct HttpJsonRpc<T = EngineApi> {
+    pub use eth2::lighthouse::DepositLog;
+
+    /// The following constants define the layout of bytes in the deposit contract `DepositEvent`. The
+    /// event bytes are formatted according to the  Ethereum ABI.
+    const PUBKEY_START: usize = 192;
+    const PUBKEY_LEN: usize = 48;
+    const CREDS_START: usize = PUBKEY_START + 64 + 32;
+    const CREDS_LEN: usize = 32;
+    const AMOUNT_START: usize = CREDS_START + 32 + 32;
+    const AMOUNT_LEN: usize = 8;
+    const SIG_START: usize = AMOUNT_START + 32 + 32;
+    const SIG_LEN: usize = 96;
+    const INDEX_START: usize = SIG_START + 96 + 32;
+    const INDEX_LEN: usize = 8;
+
+    /// A reduced set of fields from an Eth1 contract log.
+    #[derive(Debug, PartialEq, Clone)]
+    pub struct Log {
+        pub block_number: u64,
+        pub data: Vec<u8>,
+    }
+
+    impl Log {
+        /// Attempts to parse a raw `Log` from the deposit contract into a `DepositLog`.
+        pub fn to_deposit_log(&self, spec: &ChainSpec) -> Result<DepositLog, String> {
+            let bytes = &self.data;
+
+            let pubkey = bytes
+                .get(PUBKEY_START..PUBKEY_START + PUBKEY_LEN)
+                .ok_or("Insufficient bytes for pubkey")?;
+            let withdrawal_credentials = bytes
+                .get(CREDS_START..CREDS_START + CREDS_LEN)
+                .ok_or("Insufficient bytes for withdrawal credential")?;
+            let amount = bytes
+                .get(AMOUNT_START..AMOUNT_START + AMOUNT_LEN)
+                .ok_or("Insufficient bytes for amount")?;
+            let signature = bytes
+                .get(SIG_START..SIG_START + SIG_LEN)
+                .ok_or("Insufficient bytes for signature")?;
+            let index = bytes
+                .get(INDEX_START..INDEX_START + INDEX_LEN)
+                .ok_or("Insufficient bytes for index")?;
+
+            let deposit_data = DepositData {
+                pubkey: PublicKeyBytes::from_ssz_bytes(pubkey)
+                    .map_err(|e| format!("Invalid pubkey ssz: {:?}", e))?,
+                withdrawal_credentials: Hash256::from_ssz_bytes(withdrawal_credentials)
+                    .map_err(|e| format!("Invalid withdrawal_credentials ssz: {:?}", e))?,
+                amount: u64::from_ssz_bytes(amount)
+                    .map_err(|e| format!("Invalid amount ssz: {:?}", e))?,
+                signature: SignatureBytes::from_ssz_bytes(signature)
+                    .map_err(|e| format!("Invalid signature ssz: {:?}", e))?,
+            };
+
+            let signature_is_valid = deposit_pubkey_signature_message(&deposit_data, spec)
+                .map_or(false, |(public_key, signature, msg)| {
+                    signature.verify(&public_key, msg)
+                });
+
+            Ok(DepositLog {
+                deposit_data,
+                block_number: self.block_number,
+                index: u64::from_ssz_bytes(index)
+                    .map_err(|e| format!("Invalid index ssz: {:?}", e))?,
+                signature_is_valid,
+            })
+        }
+    }
+
+    #[cfg(test)]
+    pub mod tests {
+        use super::*;
+        use types::{EthSpec, MainnetEthSpec};
+
+        /// The data from a deposit event, using the v0.8.3 version of the deposit contract.
+        pub const EXAMPLE_LOG: &[u8] = &[
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 167, 108, 6, 69, 88, 17,
+            3, 51, 6, 4, 158, 232, 82, 248, 218, 2, 71, 219, 55, 102, 86, 125, 136, 203, 36, 77,
+            64, 213, 43, 52, 175, 154, 239, 50, 142, 52, 201, 77, 54, 239, 0, 229, 22, 46, 139,
+            120, 62, 240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            8, 0, 64, 89, 115, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 96, 140, 74, 175, 158, 209, 20, 206, 30, 63, 215, 238, 113, 60,
+            132, 216, 211, 100, 186, 202, 71, 34, 200, 160, 225, 212, 213, 119, 88, 51, 80, 101,
+            74, 2, 45, 78, 153, 12, 192, 44, 51, 77, 40, 10, 72, 246, 34, 193, 187, 22, 95, 4, 211,
+            245, 224, 13, 162, 21, 163, 54, 225, 22, 124, 3, 56, 14, 81, 122, 189, 149, 250, 251,
+            159, 22, 77, 94, 157, 197, 196, 253, 110, 201, 88, 193, 246, 136, 226, 221, 18, 113,
+            232, 105, 100, 114, 103, 237, 189, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ];
+
+        #[test]
+        fn can_parse_example_log() {
+            let log = Log {
+                block_number: 42,
+                data: EXAMPLE_LOG.to_vec(),
+            };
+            log.to_deposit_log(&MainnetEthSpec::default_spec())
+                .expect("should decode log");
+        }
+    }
+}
+
+/// Contains subset of the HTTP JSON-RPC methods used to query an execution node for
+/// state of the deposit contract.
+pub mod deposit_methods {
+    use super::Log;
+    use crate::HttpJsonRpc;
+    use serde::{Deserialize, Serialize};
+    use serde_json::{json, Value};
+    use std::fmt;
+    use std::ops::Range;
+    use std::str::FromStr;
+    use std::time::Duration;
+    use types::Hash256;
+
+    /// `keccak("DepositEvent(bytes,bytes,bytes,bytes,bytes)")`
+    pub const DEPOSIT_EVENT_TOPIC: &str =
+        "0x649bbc62d0e31342afea4e5cd82d4049e7e1ee912fc0889aa790803be39038c5";
+    /// `keccak("get_deposit_root()")[0..4]`
+    pub const DEPOSIT_ROOT_FN_SIGNATURE: &str = "0xc5f2892f";
+    /// `keccak("get_deposit_count()")[0..4]`
+    pub const DEPOSIT_COUNT_FN_SIGNATURE: &str = "0x621fd130";
+
+    /// Number of bytes in deposit contract deposit root response.
+    pub const DEPOSIT_COUNT_RESPONSE_BYTES: usize = 96;
+    /// Number of bytes in deposit contract deposit root (value only).
+    pub const DEPOSIT_ROOT_BYTES: usize = 32;
+
+    /// Represents an eth1 chain/network id.
+    #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+    pub enum Eth1Id {
+        Goerli,
+        Mainnet,
+        Custom(u64),
+    }
+
+    #[derive(Debug, PartialEq, Clone)]
+    pub struct Block {
+        pub hash: Hash256,
+        pub timestamp: u64,
+        pub number: u64,
+    }
+
+    /// Used to identify a block when querying the Eth1 node.
+    #[derive(Clone, Copy)]
+    pub enum BlockQuery {
+        Number(u64),
+        Latest,
+    }
+
+    impl Into<u64> for Eth1Id {
+        fn into(self) -> u64 {
+            match self {
+                Eth1Id::Mainnet => 1,
+                Eth1Id::Goerli => 5,
+                Eth1Id::Custom(id) => id,
+            }
+        }
+    }
+
+    impl From<u64> for Eth1Id {
+        fn from(id: u64) -> Self {
+            let into = |x: Eth1Id| -> u64 { x.into() };
+            match id {
+                id if id == into(Eth1Id::Mainnet) => Eth1Id::Mainnet,
+                id if id == into(Eth1Id::Goerli) => Eth1Id::Goerli,
+                id => Eth1Id::Custom(id),
+            }
+        }
+    }
+
+    impl FromStr for Eth1Id {
+        type Err = String;
+
+        fn from_str(s: &str) -> Result<Self, Self::Err> {
+            s.parse::<u64>()
+                .map(Into::into)
+                .map_err(|e| format!("Failed to parse eth1 network id {}", e))
+        }
+    }
+
+    /// Represents an error received from a remote procecdure call.
+    #[derive(Debug, Serialize, Deserialize)]
+    pub enum RpcError {
+        NoResultField,
+        Eip155Error,
+        InvalidJson(String),
+        Error(String),
+    }
+
+    impl fmt::Display for RpcError {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            match self {
+                RpcError::NoResultField => write!(f, "No result field in response"),
+                RpcError::Eip155Error => write!(f, "Not synced past EIP-155"),
+                RpcError::InvalidJson(e) => write!(f, "Malformed JSON received: {}", e),
+                RpcError::Error(s) => write!(f, "{}", s),
+            }
+        }
+    }
+
+    impl From<RpcError> for String {
+        fn from(e: RpcError) -> String {
+            e.to_string()
+        }
+    }
+
+    /// Parses a `0x`-prefixed, **big-endian** hex string as a u64.
+    ///
+    /// Note: the JSON-RPC encodes integers as big-endian. The deposit contract uses little-endian.
+    /// Therefore, this function is only useful for numbers encoded by the JSON RPC.
+    ///
+    /// E.g., `0x01 == 1`
+    fn hex_to_u64_be(hex: &str) -> Result<u64, String> {
+        u64::from_str_radix(strip_prefix(hex)?, 16)
+            .map_err(|e| format!("Failed to parse hex as u64: {:?}", e))
+    }
+
+    /// Parses a `0x`-prefixed, big-endian hex string as bytes.
+    ///
+    /// E.g., `0x0102 == vec![1, 2]`
+    fn hex_to_bytes(hex: &str) -> Result<Vec<u8>, String> {
+        hex::decode(strip_prefix(hex)?)
+            .map_err(|e| format!("Failed to parse hex as bytes: {:?}", e))
+    }
+
+    /// Removes the `0x` prefix from some bytes. Returns an error if the prefix is not present.
+    fn strip_prefix(hex: &str) -> Result<&str, String> {
+        if let Some(stripped) = hex.strip_prefix("0x") {
+            Ok(stripped)
+        } else {
+            Err("Hex string did not start with `0x`".to_string())
+        }
+    }
+
+    impl HttpJsonRpc {
+        /// Get the eth1 chain id of the given endpoint.
+        pub async fn get_chain_id(&self, timeout: Duration) -> Result<Eth1Id, String> {
+            let chain_id: String = self
+                .rpc_request("eth_chainId", json!([]), timeout)
+                .await
+                .map_err(|e| format!("eth_chainId call failed {:?}", e))?;
+            hex_to_u64_be(chain_id.as_str()).map(|id| id.into())
+        }
+
+        /// Returns the current block number.
+        pub async fn get_block_number(&self, timeout: Duration) -> Result<u64, String> {
+            let response: String = self
+                .rpc_request("eth_blockNumber", json!([]), timeout)
+                .await
+                .map_err(|e| format!("eth_blockNumber call failed {:?}", e))?;
+            hex_to_u64_be(response.as_str())
+                .map_err(|e| format!("Failed to get block number: {}", e))
+        }
+
+        /// Gets a block hash by block number.
+        pub async fn get_block(
+            &self,
+            query: BlockQuery,
+            timeout: Duration,
+        ) -> Result<Block, String> {
+            let query_param = match query {
+                BlockQuery::Number(block_number) => format!("0x{:x}", block_number),
+                BlockQuery::Latest => "latest".to_string(),
+            };
+            let params = json!([
+                query_param,
+                false // do not return full tx objects.
+            ]);
+
+            let response: Value = self
+                .rpc_request("eth_getBlockByNumber", params, timeout)
+                .await
+                .map_err(|e| format!("eth_getBlockByNumber call failed {:?}", e))?;
+
+            let hash: Vec<u8> = hex_to_bytes(
+                response
+                    .get("hash")
+                    .ok_or("No hash for block")?
+                    .as_str()
+                    .ok_or("Block hash was not string")?,
+            )?;
+            let hash: Hash256 = if hash.len() == 32 {
+                Hash256::from_slice(&hash)
+            } else {
+                return Err(format!("Block hash was not 32 bytes: {:?}", hash));
+            };
+
+            let timestamp = hex_to_u64_be(
+                response
+                    .get("timestamp")
+                    .ok_or("No timestamp for block")?
+                    .as_str()
+                    .ok_or("Block timestamp was not string")?,
+            )?;
+
+            let number = hex_to_u64_be(
+                response
+                    .get("number")
+                    .ok_or("No number for block")?
+                    .as_str()
+                    .ok_or("Block number was not string")?,
+            )?;
+
+            if number <= usize::max_value() as u64 {
+                Ok(Block {
+                    hash,
+                    timestamp,
+                    number,
+                })
+            } else {
+                Err(format!("Block number {} is larger than a usize", number))
+            }
+            .map_err(|e| format!("Failed to get block number: {}", e))
+        }
+
+        /// Returns the value of the `get_deposit_count()` call at the given `address` for the given
+        /// `block_number`.
+        ///
+        /// Assumes that the `address` has the same ABI as the eth2 deposit contract.
+        pub async fn get_deposit_count(
+            &self,
+            address: &str,
+            block_number: u64,
+            timeout: Duration,
+        ) -> Result<Option<u64>, String> {
+            let result = self
+                .call(address, DEPOSIT_COUNT_FN_SIGNATURE, block_number, timeout)
+                .await?;
+            match result {
+                None => Err("Deposit root response was none".to_string()),
+                Some(bytes) => {
+                    if bytes.is_empty() {
+                        Ok(None)
+                    } else if bytes.len() == DEPOSIT_COUNT_RESPONSE_BYTES {
+                        let mut array = [0; 8];
+                        array.copy_from_slice(&bytes[32 + 32..32 + 32 + 8]);
+                        Ok(Some(u64::from_le_bytes(array)))
+                    } else {
+                        Err(format!(
+                            "Deposit count response was not {} bytes: {:?}",
+                            DEPOSIT_COUNT_RESPONSE_BYTES, bytes
+                        ))
+                    }
+                }
+            }
+        }
+
+        /// Returns the value of the `get_hash_tree_root()` call at the given `block_number`.
+        ///
+        /// Assumes that the `address` has the same ABI as the eth2 deposit contract.
+        pub async fn get_deposit_root(
+            &self,
+            address: &str,
+            block_number: u64,
+            timeout: Duration,
+        ) -> Result<Option<Hash256>, String> {
+            let result = self
+                .call(address, DEPOSIT_ROOT_FN_SIGNATURE, block_number, timeout)
+                .await?;
+            match result {
+                None => Err("Deposit root response was none".to_string()),
+                Some(bytes) => {
+                    if bytes.is_empty() {
+                        Ok(None)
+                    } else if bytes.len() == DEPOSIT_ROOT_BYTES {
+                        Ok(Some(Hash256::from_slice(&bytes)))
+                    } else {
+                        Err(format!(
+                            "Deposit root response was not {} bytes: {:?}",
+                            DEPOSIT_ROOT_BYTES, bytes
+                        ))
+                    }
+                }
+            }
+        }
+
+        /// Performs a instant, no-transaction call to the contract `address` with the given `0x`-prefixed
+        /// `hex_data`.
+        ///
+        /// Returns bytes, if any.
+        async fn call(
+            &self,
+            address: &str,
+            hex_data: &str,
+            block_number: u64,
+            timeout: Duration,
+        ) -> Result<Option<Vec<u8>>, String> {
+            let params = json! ([
+                {
+                    "to": address,
+                    "data": hex_data,
+                },
+                format!("0x{:x}", block_number)
+            ]);
+
+            let response: Option<String> = self
+                .rpc_request("eth_call", params, timeout)
+                .await
+                .map_err(|e| format!("eth_call call failed {:?}", e))?;
+
+            response.map(|s| hex_to_bytes(&s)).transpose()
+        }
+
+        /// Returns logs for the `DEPOSIT_EVENT_TOPIC`, for the given `address` in the given
+        /// `block_height_range`.
+        ///
+        /// It's not clear from the Ethereum JSON-RPC docs if this range is inclusive or not.
+        pub async fn get_deposit_logs_in_range(
+            &self,
+            address: &str,
+            block_height_range: Range<u64>,
+            timeout: Duration,
+        ) -> Result<Vec<Log>, String> {
+            let params = json! ([{
+                "address": address,
+                "topics": [DEPOSIT_EVENT_TOPIC],
+                "fromBlock": format!("0x{:x}", block_height_range.start),
+                "toBlock": format!("0x{:x}", block_height_range.end),
+            }]);
+
+            let response: Value = self
+                .rpc_request("eth_getLogs", params, timeout)
+                .await
+                .map_err(|e| format!("eth_getLogs call failed {:?}", e))?;
+            response
+                .as_array()
+                .cloned()
+                .ok_or("'result' value was not an array")?
+                .into_iter()
+                .map(|value| {
+                    let block_number = value
+                        .get("blockNumber")
+                        .ok_or("No block number field in log")?
+                        .as_str()
+                        .ok_or("Block number was not string")?;
+
+                    let data = value
+                        .get("data")
+                        .ok_or("No block number field in log")?
+                        .as_str()
+                        .ok_or("Data was not string")?;
+
+                    Ok(Log {
+                        block_number: hex_to_u64_be(block_number)?,
+                        data: hex_to_bytes(data)?,
+                    })
+                })
+                .collect::<Result<Vec<Log>, String>>()
+                .map_err(|e| format!("Failed to get logs in range: {}", e))
+        }
+    }
+}
+
+pub struct HttpJsonRpc {
     pub client: Client,
     pub url: SensitiveUrl,
     auth: Option<Auth>,
-    _phantom: PhantomData<T>,
 }
 
-impl<T> HttpJsonRpc<T> {
+impl HttpJsonRpc {
     pub fn new(url: SensitiveUrl) -> Result<Self, Error> {
         Ok(Self {
             client: Client::builder().build()?,
             url,
             auth: None,
-            _phantom: PhantomData,
         })
     }
 
@@ -70,7 +535,6 @@ impl<T> HttpJsonRpc<T> {
             client: Client::builder().build()?,
             url,
             auth: Some(auth),
-            _phantom: PhantomData,
         })
     }
 
@@ -117,7 +581,13 @@ impl<T> HttpJsonRpc<T> {
     }
 }
 
-impl HttpJsonRpc<EngineApi> {
+impl std::fmt::Display for HttpJsonRpc {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}, auth={}", self.url, self.auth.is_some())
+    }
+}
+
+impl HttpJsonRpc {
     pub async fn upcheck(&self) -> Result<(), Error> {
         let result: serde_json::Value = self
             .rpc_request(ETH_SYNCING, json!([]), ETH_SYNCING_TIMEOUT)
@@ -233,67 +703,11 @@ impl HttpJsonRpc<EngineApi> {
     }
 }
 
-impl HttpJsonRpc<BuilderApi> {
-    pub async fn get_payload_header_v1<T: EthSpec>(
-        &self,
-        payload_id: PayloadId,
-    ) -> Result<ExecutionPayloadHeader<T>, Error> {
-        let params = json!([JsonPayloadIdRequest::from(payload_id)]);
-
-        let response: JsonExecutionPayloadHeaderV1<T> = self
-            .rpc_request(
-                BUILDER_GET_PAYLOAD_HEADER_V1,
-                params,
-                BUILDER_GET_PAYLOAD_HEADER_TIMEOUT,
-            )
-            .await?;
-
-        Ok(response.into())
-    }
-
-    pub async fn forkchoice_updated_v1(
-        &self,
-        forkchoice_state: ForkChoiceState,
-        payload_attributes: Option<PayloadAttributes>,
-    ) -> Result<ForkchoiceUpdatedResponse, Error> {
-        let params = json!([
-            JsonForkChoiceStateV1::from(forkchoice_state),
-            payload_attributes.map(JsonPayloadAttributesV1::from)
-        ]);
-
-        let response: JsonForkchoiceUpdatedV1Response = self
-            .rpc_request(
-                ENGINE_FORKCHOICE_UPDATED_V1,
-                params,
-                ENGINE_FORKCHOICE_UPDATED_TIMEOUT,
-            )
-            .await?;
-
-        Ok(response.into())
-    }
-
-    pub async fn propose_blinded_block_v1<T: EthSpec>(
-        &self,
-        block: SignedBeaconBlock<T, BlindedPayload<T>>,
-    ) -> Result<ExecutionPayload<T>, Error> {
-        let params = json!([block]);
-
-        let response: JsonExecutionPayloadV1<T> = self
-            .rpc_request(
-                BUILDER_PROPOSE_BLINDED_BLOCK_V1,
-                params,
-                BUILDER_PROPOSE_BLINDED_BLOCK_TIMEOUT,
-            )
-            .await?;
-
-        Ok(response.into())
-    }
-}
 #[cfg(test)]
 mod test {
     use super::auth::JwtKey;
     use super::*;
-    use crate::test_utils::{MockServer, JWT_SECRET};
+    use crate::test_utils::{MockServer, DEFAULT_JWT_SECRET};
     use std::future::Future;
     use std::str::FromStr;
     use std::sync::Arc;
@@ -313,8 +727,10 @@ mod test {
             let echo_url = SensitiveUrl::parse(&format!("{}/echo", server.url())).unwrap();
             // Create rpc clients that include JWT auth headers if `with_auth` is true.
             let (rpc_client, echo_client) = if with_auth {
-                let rpc_auth = Auth::new(JwtKey::from_slice(&JWT_SECRET).unwrap(), None, None);
-                let echo_auth = Auth::new(JwtKey::from_slice(&JWT_SECRET).unwrap(), None, None);
+                let rpc_auth =
+                    Auth::new(JwtKey::from_slice(&DEFAULT_JWT_SECRET).unwrap(), None, None);
+                let echo_auth =
+                    Auth::new(JwtKey::from_slice(&DEFAULT_JWT_SECRET).unwrap(), None, None);
                 (
                     Arc::new(HttpJsonRpc::new_with_auth(rpc_url, rpc_auth).unwrap()),
                     Arc::new(HttpJsonRpc::new_with_auth(echo_url, echo_auth).unwrap()),

beacon_node/execution_layer/src/engine_api/json_structures.rs

@@ -78,6 +78,7 @@ pub struct JsonExecutionPayloadHeaderV1<T: EthSpec> {
     pub timestamp: u64,
     #[serde(with = "ssz_types::serde_utils::hex_var_list")]
     pub extra_data: VariableList<u8, T::MaxExtraDataBytes>,
+    #[serde(with = "eth2_serde_utils::u256_hex_be")]
     pub base_fee_per_gas: Uint256,
     pub block_hash: ExecutionBlockHash,
     pub transactions_root: Hash256,
@@ -142,6 +143,7 @@ pub struct JsonExecutionPayloadV1<T: EthSpec> {
     pub timestamp: u64,
     #[serde(with = "ssz_types::serde_utils::hex_var_list")]
     pub extra_data: VariableList<u8, T::MaxExtraDataBytes>,
+    #[serde(with = "eth2_serde_utils::u256_hex_be")]
     pub base_fee_per_gas: Uint256,
     pub block_hash: ExecutionBlockHash,
     #[serde(with = "ssz_types::serde_utils::list_of_hex_var_list")]
@@ -320,7 +322,6 @@ pub enum JsonPayloadStatusV1Status {
     Syncing,
     Accepted,
     InvalidBlockHash,
-    InvalidTerminalBlock,
 }
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -339,9 +340,6 @@ impl From<PayloadStatusV1Status> for JsonPayloadStatusV1Status {
             PayloadStatusV1Status::Syncing => JsonPayloadStatusV1Status::Syncing,
             PayloadStatusV1Status::Accepted => JsonPayloadStatusV1Status::Accepted,
             PayloadStatusV1Status::InvalidBlockHash => JsonPayloadStatusV1Status::InvalidBlockHash,
-            PayloadStatusV1Status::InvalidTerminalBlock => {
-                JsonPayloadStatusV1Status::InvalidTerminalBlock
-            }
         }
     }
 }
@@ -353,9 +351,6 @@ impl From<JsonPayloadStatusV1Status> for PayloadStatusV1Status {
             JsonPayloadStatusV1Status::Syncing => PayloadStatusV1Status::Syncing,
             JsonPayloadStatusV1Status::Accepted => PayloadStatusV1Status::Accepted,
             JsonPayloadStatusV1Status::InvalidBlockHash => PayloadStatusV1Status::InvalidBlockHash,
-            JsonPayloadStatusV1Status::InvalidTerminalBlock => {
-                PayloadStatusV1Status::InvalidTerminalBlock
-            }
         }
     }
 }
@@ -430,62 +425,10 @@ impl From<ForkchoiceUpdatedResponse> for JsonForkchoiceUpdatedV1Response {
     }
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-pub enum JsonProposeBlindedBlockResponseStatus {
-    Valid,
-    Invalid,
-    Syncing,
-}
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-#[serde(bound = "E: EthSpec")]
-pub struct JsonProposeBlindedBlockResponse<E: EthSpec> {
-    pub result: ExecutionPayload<E>,
-    pub error: Option<String>,
-}
-
-impl<E: EthSpec> From<JsonProposeBlindedBlockResponse<E>> for ExecutionPayload<E> {
-    fn from(j: JsonProposeBlindedBlockResponse<E>) -> Self {
-        let JsonProposeBlindedBlockResponse { result, error: _ } = j;
-        result
-    }
-}
-
-impl From<JsonProposeBlindedBlockResponseStatus> for ProposeBlindedBlockResponseStatus {
-    fn from(j: JsonProposeBlindedBlockResponseStatus) -> Self {
-        match j {
-            JsonProposeBlindedBlockResponseStatus::Valid => {
-                ProposeBlindedBlockResponseStatus::Valid
-            }
-            JsonProposeBlindedBlockResponseStatus::Invalid => {
-                ProposeBlindedBlockResponseStatus::Invalid
-            }
-            JsonProposeBlindedBlockResponseStatus::Syncing => {
-                ProposeBlindedBlockResponseStatus::Syncing
-            }
-        }
-    }
-}
-impl From<ProposeBlindedBlockResponseStatus> for JsonProposeBlindedBlockResponseStatus {
-    fn from(f: ProposeBlindedBlockResponseStatus) -> Self {
-        match f {
-            ProposeBlindedBlockResponseStatus::Valid => {
-                JsonProposeBlindedBlockResponseStatus::Valid
-            }
-            ProposeBlindedBlockResponseStatus::Invalid => {
-                JsonProposeBlindedBlockResponseStatus::Invalid
-            }
-            ProposeBlindedBlockResponseStatus::Syncing => {
-                JsonProposeBlindedBlockResponseStatus::Syncing
-            }
-        }
-    }
-}
-
 #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TransitionConfigurationV1 {
+    #[serde(with = "eth2_serde_utils::u256_hex_be")]
     pub terminal_total_difficulty: Uint256,
     pub terminal_block_hash: ExecutionBlockHash,
     #[serde(with = "eth2_serde_utils::u64_hex_be")]