Merge pull request #110 from ralexstokes/relay-verif

provide genesis validators root to relay for use in verification

Cargo.toml

@@ -1,15 +1,9 @@
 [workspace]
 resolver = "2"
-members = [
-    "bin/mev",
-    "mev-boost-rs",
-    "mev-relay-rs",
-    "mev-build-rs",
-    "mev-rs",
-]
+members = ["bin/mev", "mev-boost-rs", "mev-relay-rs", "mev-build-rs", "mev-rs"]
 default-members = ["bin/mev"]
 
 [workspace.dependencies]
 ethereum-consensus = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "e380108" }
-beacon-api-client = { git = "https://github.com/ralexstokes/beacon-api-client", rev = "93d7e8c" }
+beacon-api-client = { git = "https://github.com/ralexstokes/beacon-api-client", rev = "287d4dd" }
 ssz_rs = "0.9.0"

mev-boost-rs/tests/integration.rs

@@ -1,11 +1,13 @@
-use beacon_api_client::{Client as ApiClient, ValidatorStatus, ValidatorSummary, Value};
+use beacon_api_client::{
+    Client as ApiClient, GenesisDetails, ValidatorStatus, ValidatorSummary, Value,
+};
 use ethereum_consensus::{
     bellatrix::mainnet as bellatrix,
     builder::{SignedValidatorRegistration, ValidatorRegistration},
     capella::mainnet as capella,
     crypto::SecretKey,
     phase0::mainnet::{compute_domain, Validator},
-    primitives::{DomainType, ExecutionAddress, Hash32},
+    primitives::{DomainType, ExecutionAddress, Hash32, Root},
     signing::sign_with_domain,
     state_transition::{Context, Forks},
 };
@@ -88,12 +90,23 @@ async fn test_end_to_end() {
             },
         })
         .collect::<Vec<_>>();
+    // relay demands validators endpoint
     validator_mock_server.mock(|when, then| {
         when.method(GET).path("/eth/v1/beacon/states/head/validators");
         let response =
             serde_json::to_string(&Value { data: validators, meta: HashMap::new() }).unwrap();
         then.status(200).body(response);
     });
+    // relay demands genesis details endpoint
+    let mut genesis_details = GenesisDetails::default();
+    let genesis_validators_root = Root::try_from([23u8; 32].as_ref()).unwrap();
+    genesis_details.genesis_validators_root = genesis_validators_root;
+    validator_mock_server.mock(|when, then| {
+        when.method(GET).path("/eth/v1/beacon/genesis");
+        let response =
+            serde_json::to_string(&Value { data: genesis_details, meta: HashMap::new() }).unwrap();
+        then.status(200).body(response);
+    });
 
     let mut context = Context::for_mainnet();
     // mock epoch values to transition across forks
@@ -155,7 +168,7 @@ async fn test_end_to_end() {
     proposers.shuffle(&mut rng);
 
     for (i, proposer) in proposers.iter().enumerate() {
-        propose_block(&beacon_node, proposer, i, &context).await;
+        propose_block(&beacon_node, proposer, i, &context, &genesis_validators_root).await;
     }
 }
 
@@ -164,6 +177,7 @@ async fn propose_block(
     proposer: &Proposer,
     shuffling_index: usize,
     context: &Context,
+    genesis_validators_root: &Root,
 ) {
     let fork = if shuffling_index == 0 { Forks::Bellatrix } else { Forks::Capella };
     let current_slot = match fork {
@@ -199,9 +213,13 @@ async fn propose_block(
                 ..Default::default()
             };
             let fork_version = context.bellatrix_fork_version;
-            let domain =
-                compute_domain(DomainType::BeaconProposer, Some(fork_version), None, context)
-                    .unwrap();
+            let domain = compute_domain(
+                DomainType::BeaconProposer,
+                Some(fork_version),
+                Some(*genesis_validators_root),
+                context,
+            )
+            .unwrap();
             let signature =
                 sign_with_domain(&mut beacon_block, &proposer.signing_key, domain).unwrap();
             let signed_block =
@@ -224,9 +242,13 @@ async fn propose_block(
                 ..Default::default()
             };
             let fork_version = context.capella_fork_version;
-            let domain =
-                compute_domain(DomainType::BeaconProposer, Some(fork_version), None, context)
-                    .unwrap();
+            let domain = compute_domain(
+                DomainType::BeaconProposer,
+                Some(fork_version),
+                Some(*genesis_validators_root),
+                context,
+            )
+            .unwrap();
             let signature =
                 sign_with_domain(&mut beacon_block, &proposer.signing_key, domain).unwrap();
             let signed_block =

mev-relay-rs/src/relay.rs

@@ -4,7 +4,7 @@ use ethereum_consensus::{
     builder::ValidatorRegistration,
     clock::get_current_unix_time_in_secs,
     crypto::SecretKey,
-    primitives::{BlsPublicKey, Slot, U256},
+    primitives::{BlsPublicKey, Root, Slot, U256},
     state_transition::Context,
 };
 use mev_build_rs::NullBuilder;
@@ -61,7 +61,8 @@ fn validate_execution_payload(
 fn validate_signed_block(
     signed_block: &mut SignedBlindedBeaconBlock,
     public_key: &BlsPublicKey,
-    local_payload: &mut ExecutionPayload,
+    local_payload: &ExecutionPayload,
+    genesis_validators_root: &Root,
     context: &Context,
 ) -> Result<(), Error> {
     let local_block_hash = local_payload.block_hash();
@@ -75,9 +76,8 @@ fn validate_signed_block(
     // verify slot is timely
     // verify proposer_index is correct
     // verify parent_root matches
-    // TODO: use real root value
-    let root = Default::default();
-    Ok(signed_block.verify_signature(public_key, root, context)?)
+
+    signed_block.verify_signature(public_key, *genesis_validators_root, context).map_err(From::from)
 }
 
 #[derive(Clone)]
@@ -94,6 +94,7 @@ impl Deref for Relay {
 pub struct Inner {
     secret_key: SecretKey,
     public_key: BlsPublicKey,
+    genesis_validators_root: Root,
     builder: NullBuilder,
     validator_registry: ValidatorRegistry,
     context: Arc<Context>,
@@ -106,12 +107,18 @@ struct State {
 }
 
 impl Relay {
-    pub fn new(beacon_node: Client, secret_key: SecretKey, context: Arc<Context>) -> Self {
+    pub fn new(
+        genesis_validators_root: Root,
+        beacon_node: Client,
+        secret_key: SecretKey,
+        context: Arc<Context>,
+    ) -> Self {
         let public_key = secret_key.public_key();
         let validator_registry = ValidatorRegistry::new(beacon_node);
         let inner = Inner {
             secret_key,
             public_key,
+            genesis_validators_root,
             builder: NullBuilder,
             validator_registry,
             context,
@@ -214,12 +221,18 @@ impl BlindedBlockProvider for Relay {
             self.validator_registry.get_public_key(proposer_index).map_err(Error::from)?;
         let bid_request = BidRequest { slot, parent_hash, public_key };
 
-        let mut payload = {
+        let payload = {
             let mut state = self.state.lock();
             state.execution_payloads.remove(&bid_request).ok_or(Error::UnknownBid)?
         };
 
-        validate_signed_block(signed_block, &bid_request.public_key, &mut payload, &self.context)?;
+        validate_signed_block(
+            signed_block,
+            &bid_request.public_key,
+            &payload,
+            &self.genesis_validators_root,
+            &self.context,
+        )?;
 
         Ok(payload)
     }

mev-relay-rs/src/service.rs

@@ -72,7 +72,9 @@ impl Service {
             if let Some(context) = context { context } else { Context::try_from(&network)? };
         let clock = context.clock(None);
         let context = Arc::new(context);
-        let relay = Relay::new(beacon_node, secret_key, context);
+        let genesis_details = beacon_node.get_genesis_details().await?;
+        let genesis_validators_root = genesis_details.genesis_validators_root;
+        let relay = Relay::new(genesis_validators_root, beacon_node, secret_key, context);
         relay.initialize().await;
 
         let block_provider = relay.clone();