Update to spec v0.11 (#959)

* Update process_final_updates() hysteresis computation

* Update core to v0.11.1

* Bump tags to v0.11.1

* Update docs and deposit contract

* Add compute_fork_digest

* Address review comments

Co-authored-by: Herman Alonso Junge <alonso.junge@gmail.com>

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -153,6 +153,8 @@ pub struct HeadInfo {
     pub current_justified_checkpoint: types::Checkpoint,
     pub finalized_checkpoint: types::Checkpoint,
     pub fork: Fork,
+    pub genesis_time: u64,
+    pub genesis_validators_root: Hash256,
 }
 
 pub trait BeaconChainTypes: Send + Sync + 'static {
@@ -492,6 +494,8 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             current_justified_checkpoint: head.beacon_state.current_justified_checkpoint.clone(),
             finalized_checkpoint: head.beacon_state.finalized_checkpoint.clone(),
             fork: head.beacon_state.fork.clone(),
+            genesis_time: head.beacon_state.genesis_time,
+            genesis_validators_root: head.beacon_state.genesis_validators_root,
         })
     }
 
@@ -1031,17 +1035,23 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             })
             .collect::<Result<Vec<&PublicKey>, Error>>()?;
 
-        let fork = self
+        let (fork, genesis_validators_root) = self
             .canonical_head
             .try_read_for(HEAD_LOCK_TIMEOUT)
             .ok_or_else(|| Error::CanonicalHeadLockTimeout)
-            .map(|head| head.beacon_state.fork.clone())?;
+            .map(|head| {
+                (
+                    head.beacon_state.fork.clone(),
+                    head.beacon_state.genesis_validators_root,
+                )
+            })?;
 
         let signature_set = indexed_attestation_signature_set_from_pubkeys(
             pubkeys,
             &attestation.signature,
             &indexed_attestation,
             &fork,
+            genesis_validators_root,
             &self.spec,
         )
         .map_err(Error::SignatureSetError)?;
@@ -1074,8 +1084,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             // Provide the valid attestation to op pool, which may choose to retain the
             // attestation for inclusion in a future block.
             if self.eth1_chain.is_some() {
-                self.op_pool
-                    .insert_attestation(attestation, &fork, &self.spec)?;
+                self.op_pool.insert_attestation(
+                    attestation,
+                    &fork,
+                    genesis_validators_root,
+                    &self.spec,
+                )?;
             };
 
             Ok(AttestationProcessingOutcome::Processed)
@@ -1547,6 +1561,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let mut block = SignedBeaconBlock {
             message: BeaconBlock {
                 slot: state.slot,
+                proposer_index: state.get_beacon_proposer_index(state.slot, &self.spec)? as u64,
                 parent_root,
                 state_root: Hash256::zero(),
                 body: BeaconBlockBody {

beacon_node/beacon_chain/src/test_utils.rs

@@ -313,7 +313,9 @@ where
 
         let randao_reveal = {
             let epoch = slot.epoch(E::slots_per_epoch());
-            let domain = self.spec.get_domain(epoch, Domain::Randao, fork);
+            let domain =
+                self.spec
+                    .get_domain(epoch, Domain::Randao, fork, state.genesis_validators_root);
             let message = epoch.signing_root(domain);
             Signature::new(message.as_bytes(), sk)
         };
@@ -323,7 +325,7 @@ where
             .produce_block_on_state(state, slot, randao_reveal)
             .expect("should produce block");
 
-        let signed_block = block.sign(sk, &state.fork, &self.spec);
+        let signed_block = block.sign(sk, &state.fork, state.genesis_validators_root, &self.spec);
 
         (signed_block, state)
     }
@@ -408,6 +410,7 @@ where
                                     attestation.data.target.epoch,
                                     Domain::BeaconAttester,
                                     fork,
+                                    state.genesis_validators_root,
                                 );
 
                                 let message = attestation.data.signing_root(domain);

beacon_node/rest_api/src/beacon.rs

@@ -494,7 +494,15 @@ pub fn get_genesis_time<T: BeaconChainTypes>(
     req: Request<Body>,
     beacon_chain: Arc<BeaconChain<T>>,
 ) -> ApiResult {
-    ResponseBuilder::new(&req)?.body(&beacon_chain.head()?.beacon_state.genesis_time)
+    ResponseBuilder::new(&req)?.body(&beacon_chain.head_info()?.genesis_time)
+}
+
+/// Read the `genesis_validators_root` from the current beacon chain state.
+pub fn get_genesis_validators_root<T: BeaconChainTypes>(
+    req: Request<Body>,
+    beacon_chain: Arc<BeaconChain<T>>,
+) -> ApiResult {
+    ResponseBuilder::new(&req)?.body(&beacon_chain.head_info()?.genesis_validators_root)
 }
 
 pub fn proposer_slashing<T: BeaconChainTypes>(

beacon_node/rest_api/src/consensus.rs

@@ -37,13 +37,13 @@ pub struct VoteCount {
 impl Into<VoteCount> for TotalBalances {
     fn into(self) -> VoteCount {
         VoteCount {
-            current_epoch_active_gwei: self.current_epoch,
-            previous_epoch_active_gwei: self.previous_epoch,
-            current_epoch_attesting_gwei: self.current_epoch_attesters,
-            current_epoch_target_attesting_gwei: self.current_epoch_target_attesters,
-            previous_epoch_attesting_gwei: self.previous_epoch_attesters,
-            previous_epoch_target_attesting_gwei: self.previous_epoch_target_attesters,
-            previous_epoch_head_attesting_gwei: self.previous_epoch_head_attesters,
+            current_epoch_active_gwei: self.current_epoch(),
+            previous_epoch_active_gwei: self.previous_epoch(),
+            current_epoch_attesting_gwei: self.current_epoch_attesters(),
+            current_epoch_target_attesting_gwei: self.current_epoch_target_attesters(),
+            previous_epoch_attesting_gwei: self.previous_epoch_attesters(),
+            previous_epoch_target_attesting_gwei: self.previous_epoch_target_attesters(),
+            previous_epoch_head_attesting_gwei: self.previous_epoch_head_attesters(),
         }
     }
 }

beacon_node/rest_api/src/router.rs

@@ -82,6 +82,9 @@ pub fn route<T: BeaconChainTypes>(
             (&Method::GET, "/beacon/genesis_time") => {
                 into_boxfut(beacon::get_genesis_time::<T>(req, beacon_chain))
             }
+            (&Method::GET, "/beacon/genesis_validators_root") => {
+                into_boxfut(beacon::get_genesis_validators_root::<T>(req, beacon_chain))
+            }
             (&Method::GET, "/beacon/validators") => {
                 into_boxfut(beacon::get_validators::<T>(req, beacon_chain))
             }

beacon_node/rest_api/tests/test.rs

@@ -47,17 +47,15 @@ fn get_randao_reveal<T: BeaconChainTypes>(
     slot: Slot,
     spec: &ChainSpec,
 ) -> Signature {
-    let fork = beacon_chain
-        .head()
-        .expect("should get head")
-        .beacon_state
-        .fork;
+    let head = beacon_chain.head().expect("should get head");
+    let fork = head.beacon_state.fork;
+    let genesis_validators_root = head.beacon_state.genesis_validators_root;
     let proposer_index = beacon_chain
         .block_proposer(slot)
         .expect("should get proposer index");
     let keypair = generate_deterministic_keypair(proposer_index);
     let epoch = slot.epoch(E::slots_per_epoch());
-    let domain = spec.get_domain(epoch, Domain::Randao, &fork);
+    let domain = spec.get_domain(epoch, Domain::Randao, &fork, genesis_validators_root);
     let message = epoch.signing_root(domain);
     Signature::new(message.as_bytes(), &keypair.sk)
 }
@@ -68,16 +66,14 @@ fn sign_block<T: BeaconChainTypes>(
     block: BeaconBlock<T::EthSpec>,
     spec: &ChainSpec,
 ) -> SignedBeaconBlock<T::EthSpec> {
-    let fork = beacon_chain
-        .head()
-        .expect("should get head")
-        .beacon_state
-        .fork;
+    let head = beacon_chain.head().expect("should get head");
+    let fork = head.beacon_state.fork;
+    let genesis_validators_root = head.beacon_state.genesis_validators_root;
     let proposer_index = beacon_chain
         .block_proposer(block.slot)
         .expect("should get proposer index");
     let keypair = generate_deterministic_keypair(proposer_index);
-    block.sign(&keypair.sk, &fork, spec)
+    block.sign(&keypair.sk, &fork, genesis_validators_root, spec)
 }
 
 #[test]
@@ -156,6 +152,7 @@ fn validator_produce_attestation() {
                 .attestation_committee_position
                 .expect("should have committee position"),
             &state.fork,
+            state.genesis_validators_root,
             spec,
         )
         .expect("should sign attestation");
@@ -564,6 +561,31 @@ fn genesis_time() {
     );
 }
 
+#[test]
+fn genesis_validators_root() {
+    let mut env = build_env();
+
+    let node = build_node(&mut env, testing_client_config());
+    let remote_node = node.remote_node().expect("should produce remote node");
+
+    let genesis_validators_root = env
+        .runtime()
+        .block_on(remote_node.http.beacon().get_genesis_validators_root())
+        .expect("should fetch genesis time from http api");
+
+    assert_eq!(
+        node.client
+            .beacon_chain()
+            .expect("should have beacon chain")
+            .head()
+            .expect("should get head")
+            .beacon_state
+            .genesis_validators_root,
+        genesis_validators_root,
+        "should match genesis time from head state"
+    );
+}
+
 #[test]
 fn fork() {
     let mut env = build_env();
@@ -903,6 +925,7 @@ fn proposer_slashing() {
         proposer_index as u64,
         &key,
         fork,
+        state.genesis_validators_root,
         spec,
     );
 
@@ -927,6 +950,7 @@ fn proposer_slashing() {
         proposer_index as u64,
         &key,
         fork,
+        state.genesis_validators_root,
         spec,
     );
     invalid_proposer_slashing.signed_header_2 = invalid_proposer_slashing.signed_header_1.clone();
@@ -981,6 +1005,7 @@ fn attester_slashing() {
         &validator_indices[..],
         &secret_keys[..],
         fork,
+        state.genesis_validators_root,
         spec,
     );
 
@@ -1006,6 +1031,7 @@ fn attester_slashing() {
         &validator_indices[..],
         &secret_keys[..],
         fork,
+        state.genesis_validators_root,
         spec,
     );
     invalid_attester_slashing.attestation_2 = invalid_attester_slashing.attestation_1.clone();

beacon_node/store/src/partial_beacon_state.rs

@@ -11,7 +11,7 @@ use types::*;
 ///
 /// Utilises lazy-loading from separate storage for its vector fields.
 ///
-/// Spec v0.10.1
+/// Spec v0.11.1
 #[derive(Debug, PartialEq, Clone, Encode, Decode)]
 pub struct PartialBeaconState<T>
 where
@@ -19,6 +19,7 @@ where
 {
     // Versioning
     pub genesis_time: u64,
+    pub genesis_validators_root: Hash256,
     pub slot: Slot,
     pub fork: Fork,
 
@@ -72,6 +73,7 @@ impl<T: EthSpec> PartialBeaconState<T> {
         // TODO: could use references/Cow for fields to avoid cloning
         PartialBeaconState {
             genesis_time: s.genesis_time,
+            genesis_validators_root: s.genesis_validators_root,
             slot: s.slot,
             fork: s.fork.clone(),
 
@@ -181,6 +183,7 @@ impl<E: EthSpec> TryInto<BeaconState<E>> for PartialBeaconState<E> {
 
         Ok(BeaconState {
             genesis_time: self.genesis_time,
+            genesis_validators_root: self.genesis_validators_root,
             slot: self.slot,
             fork: self.fork,