Modify create_proof_of_possession, and verifying proof_of_possession in process_deposits

eth2/types/src/beacon_state.rs

@@ -1,7 +1,6 @@
 use self::epoch_cache::EpochCache;
 use crate::test_utils::TestRandom;
 use crate::{validator_registry::get_active_validator_indices, *};
-use bls::verify_proof_of_possession;
 use helpers::*;
 use honey_badger_split::SplitExt;
 use int_to_bytes::int_to_bytes32;
@@ -9,7 +8,7 @@ use log::{debug, error, trace};
 use rand::RngCore;
 use rayon::prelude::*;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, Decodable, DecodeError, Encodable, SignedRoot, SszStream, TreeHash};
 use std::collections::HashMap;
 use swap_or_not_shuffle::shuffle_list;
 
@@ -590,10 +589,8 @@ impl BeaconState {
 
         for deposit_data in deposits {
             let result = self.process_deposit(
-                deposit_data.deposit_input.pubkey.clone(),
+                deposit_data.deposit_input.clone(),
                 deposit_data.amount,
-                deposit_data.deposit_input.proof_of_possession.clone(),
-                deposit_data.deposit_input.withdrawal_credentials,
                 Some(&pubkey_map),
                 spec,
             );
@@ -616,18 +613,29 @@ impl BeaconState {
     /// Spec v0.4.0
     pub fn process_deposit(
         &mut self,
-        pubkey: PublicKey,
+        deposit_input: DepositInput,
         amount: u64,
-        proof_of_possession: Signature,
-        withdrawal_credentials: Hash256,
         pubkey_map: Option<&HashMap<PublicKey, usize>>,
         spec: &ChainSpec,
     ) -> Result<usize, ()> {
-        //
-        if !verify_proof_of_possession(&proof_of_possession, &pubkey) {
-            return Err(());
+
+        let proof_is_valid = deposit_input.proof_of_possession.verify(
+            &deposit_input.signed_root(),
+            spec.get_domain(
+                self.current_epoch(&spec),
+                Domain::Deposit,
+                &self.fork,
+            ),
+            &deposit_input.pubkey,
+        );
+
+        if !proof_is_valid {
+            return Err(())
         }
 
+        let pubkey = deposit_input.pubkey.clone();
+        let withdrawal_credentials = deposit_input.withdrawal_credentials.clone();
+
         let validator_index = if let Some(pubkey_map) = pubkey_map {
             pubkey_map.get(&pubkey).and_then(|i| Some(*i))
         } else {
@@ -1055,33 +1063,6 @@ impl BeaconState {
         self.validator_registry_update_epoch = current_epoch;
     }
 
-    /// Confirm validator owns PublicKey
-    ///
-    /// Spec v0.4.0
-    pub fn validate_proof_of_possession(
-        &self,
-        pubkey: PublicKey,
-        proof_of_possession: Signature,
-        withdrawal_credentials: Hash256,
-        spec: &ChainSpec,
-    ) -> bool {
-        let proof_of_possession_data = DepositInput {
-            pubkey: pubkey.clone(),
-            withdrawal_credentials,
-            proof_of_possession: Signature::empty_signature(),
-        };
-
-        proof_of_possession.verify(
-            &proof_of_possession_data.hash_tree_root(),
-            spec.get_domain(
-                self.slot.epoch(spec.slots_per_epoch),
-                Domain::Deposit,
-                &self.fork,
-            ),
-            &pubkey,
-        )
-    }
-
     /// Iterate through the validator registry and eject active validators with balance below
     /// ``EJECTION_BALANCE``.
     ///

eth2/types/src/deposit_input.rs

@@ -1,21 +1,37 @@
 use super::Hash256;
 use crate::test_utils::TestRandom;
-use bls::{PublicKey, Signature};
+use bls::{Keypair, PublicKey, Signature};
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
-use ssz_derive::{Decode, Encode, TreeHash};
+use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
+use ssz::{SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
 
 /// The data supplied by the user to the deposit contract.
 ///
 /// Spec v0.4.0
-#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, SignedRoot, TreeHash, TestRandom)]
 pub struct DepositInput {
     pub pubkey: PublicKey,
     pub withdrawal_credentials: Hash256,
     pub proof_of_possession: Signature,
 }
 
+impl DepositInput {
+    /// Generate the 'proof_of_posession' signature for a given DepositInput details.
+    ///
+    /// Spec v0.4.0
+    pub fn create_proof_of_possession(keypair: &Keypair, withdrawal_credentials: &Hash256, domain: u64) -> Signature {
+        let signable_deposite_input = DepositInput {
+            pubkey: keypair.pk.clone(),
+            withdrawal_credentials: withdrawal_credentials.clone(),
+            proof_of_possession: Signature::empty_signature(),
+        };
+        let msg = signable_deposite_input.signed_root();
+        Signature::new(msg.as_slice(), domain, &keypair.sk)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

eth2/types/src/test_utils/testing_beacon_block_builder.rs

@@ -153,12 +153,12 @@ impl TestingBeaconBlockBuilder {
     }
 
     /// Insert a `Valid` deposit into the state.
-    pub fn insert_deposit(&mut self, amount: u64, index: u64, spec: &ChainSpec) {
+    pub fn insert_deposit(&mut self, amount: u64, index: u64, domain: u64, spec: &ChainSpec) {
         let keypair = Keypair::random();
 
         let mut builder = TestingDepositBuilder::new(amount);
         builder.set_index(index);
-        builder.sign(&keypair, spec);
+        builder.sign(&keypair, domain, spec);
 
         self.block.body.deposits.push(builder.build())
     }

eth2/types/src/test_utils/testing_deposit_builder.rs

@@ -1,5 +1,5 @@
 use crate::*;
-use bls::{create_proof_of_possession, get_withdrawal_credentials};
+use bls::{get_withdrawal_credentials};
 
 pub struct TestingDepositBuilder {
     deposit: Deposit,
@@ -30,16 +30,16 @@ impl TestingDepositBuilder {
         self.deposit.index = index;
     }
 
-    pub fn sign(&mut self, keypair: &Keypair, spec: &ChainSpec) {
+    pub fn sign(&mut self, keypair: &Keypair, domain: u64, spec: &ChainSpec) {
+        let withdrawal_credentials = Hash256::from_slice(&get_withdrawal_credentials(&keypair.pk, spec.bls_withdrawal_prefix_byte)[..]);
         self.deposit.deposit_data.deposit_input.pubkey = keypair.pk.clone();
+        self.deposit.deposit_data.deposit_input.withdrawal_credentials = withdrawal_credentials.clone();
         self.deposit.deposit_data.deposit_input.proof_of_possession =
-            create_proof_of_possession(&keypair);
-        self.deposit
-            .deposit_data
-            .deposit_input
-            .withdrawal_credentials = Hash256::from_slice(
-            &get_withdrawal_credentials(&keypair.pk, spec.bls_withdrawal_prefix_byte)[..],
-        );
+            DepositInput::create_proof_of_possession(
+                &keypair,
+                &withdrawal_credentials,
+                domain,
+            );
     }
 
     pub fn build(self) -> Deposit {