Bulk signature verification (#507)

* Add basic block processing benches

* Start reviving state processing benches

* Fix old block builders

* Add optimization for faster pubkey add

* Tidy benches, add another

* Add extra block processing bench

* Start working on faster BLS scheme

* Add partially complete sig verify optimization

* Add .gitignore to state processing

* Add progress on faster signature verification

* Fix SignatureSet for fake_crypto

* Tidy attester slashings sig set

* Tidy bulk signature verifier

* Refactor signature sets to be cleaner

* Start threading SignatureStrategy through code

* Add (empty) test dir

* Move BenchingBlockBuilder

* Add initial block signature verification tests

* Add tests for bulk signature verification

* Start threading SignatureStrategy in block proc.

* Refactor per_block_processing errors

* Use sig set tuples instead of lists of two

* Remove dead code

* Thread VerifySignatures through per_block_processing

* Add bulk signature verification

* Introduce parallel bulk signature verification

* Expand state processing benches

* Fix additional compile errors

* Fix issue where par iter chunks is 0

* Update milagro_bls dep

* Remove debugs, code fragment in beacon chain

* Tidy, add comments to block sig verifier

* Fix various PR comments

* Add block_root option to per_block_processing

* Fix comment in block signature verifier

* Fix comments from PR review

* Remove old comment

* Fix comment

eth2/operation_pool/src/lib.rs

@@ -16,9 +16,9 @@ use state_processing::per_block_processing::errors::{
 };
 use state_processing::per_block_processing::{
     get_slashable_indices_modular, verify_attestation_for_block_inclusion,
-    verify_attester_slashing, verify_exit, verify_exit_time_independent_only,
-    verify_proposer_slashing, verify_transfer, verify_transfer_time_independent_only,
-    VerifySignatures,
+    verify_attestation_for_state, verify_attester_slashing, verify_exit,
+    verify_exit_time_independent_only, verify_proposer_slashing, verify_transfer,
+    verify_transfer_time_independent_only, VerifySignatures,
 };
 use std::collections::{btree_map::Entry, hash_map, BTreeMap, HashMap, HashSet};
 use std::marker::PhantomData;
@@ -134,8 +134,8 @@ impl<T: EthSpec> OperationPool<T> {
                 verify_attestation_for_block_inclusion(
                     state,
                     attestation,
-                    spec,
                     VerifySignatures::True,
+                    spec,
                 )
                 .is_ok()
             })
@@ -220,7 +220,7 @@ impl<T: EthSpec> OperationPool<T> {
     ) -> Result<(), ProposerSlashingValidationError> {
         // TODO: should maybe insert anyway if the proposer is unknown in the validator index,
         // because they could *become* known later
-        verify_proposer_slashing(&slashing, state, spec)?;
+        verify_proposer_slashing(&slashing, state, VerifySignatures::True, spec)?;
         self.proposer_slashings
             .write()
             .insert(slashing.proposer_index, slashing);
@@ -248,7 +248,7 @@ impl<T: EthSpec> OperationPool<T> {
         state: &BeaconState<T>,
         spec: &ChainSpec,
     ) -> Result<(), AttesterSlashingValidationError> {
-        verify_attester_slashing(state, &slashing, true, spec)?;
+        verify_attester_slashing(state, &slashing, true, VerifySignatures::True, spec)?;
         let id = Self::attester_slashing_id(&slashing, state, spec);
         self.attester_slashings.write().insert(id, slashing);
         Ok(())
@@ -346,7 +346,7 @@ impl<T: EthSpec> OperationPool<T> {
         state: &BeaconState<T>,
         spec: &ChainSpec,
     ) -> Result<(), ExitValidationError> {
-        verify_exit_time_independent_only(state, &exit, spec)?;
+        verify_exit_time_independent_only(state, &exit, VerifySignatures::True, spec)?;
         self.voluntary_exits
             .write()
             .insert(exit.validator_index, exit);
@@ -361,7 +361,7 @@ impl<T: EthSpec> OperationPool<T> {
     ) -> Vec<VoluntaryExit> {
         filter_limit_operations(
             self.voluntary_exits.read().values(),
-            |exit| verify_exit(state, exit, spec).is_ok(),
+            |exit| verify_exit(state, exit, VerifySignatures::False, spec).is_ok(),
             T::MaxVoluntaryExits::to_usize(),
         )
     }
@@ -385,7 +385,7 @@ impl<T: EthSpec> OperationPool<T> {
         // The signature of the transfer isn't hashed, but because we check
         // it before we insert into the HashSet, we can't end up with duplicate
         // transactions.
-        verify_transfer_time_independent_only(state, &transfer, spec)?;
+        verify_transfer_time_independent_only(state, &transfer, VerifySignatures::True, spec)?;
         self.transfers.write().insert(transfer);
         Ok(())
     }
@@ -397,7 +397,9 @@ impl<T: EthSpec> OperationPool<T> {
         self.transfers
             .read()
             .iter()
-            .filter(|transfer| verify_transfer(state, transfer, spec).is_ok())
+            .filter(|transfer| {
+                verify_transfer(state, transfer, VerifySignatures::False, spec).is_ok()
+            })
             .sorted_by_key(|transfer| std::cmp::Reverse(transfer.fee))
             .take(T::MaxTransfers::to_usize())
             .cloned()