Implement transaction pool basics

eth2/state_processing/src/per_block_processing.rs

@@ -1,4 +1,3 @@
-use self::verify_proposer_slashing::verify_proposer_slashing;
 use crate::common::slash_validator;
 use errors::{BlockInvalid as Invalid, BlockProcessingError as Error, IntoWithIndex};
 use rayon::prelude::*;
@@ -8,11 +7,15 @@ use types::*;
 pub use self::verify_attester_slashing::{
     gather_attester_slashing_indices, verify_attester_slashing,
 };
+pub use self::verify_proposer_slashing::verify_proposer_slashing;
 pub use validate_attestation::{validate_attestation, validate_attestation_without_signature};
-pub use verify_deposit::{get_existing_validator_index, verify_deposit, verify_deposit_index};
+pub use verify_deposit::{
+    get_existing_validator_index, verify_deposit, verify_deposit_index,
+    verify_deposit_merkle_proof,
+};
 pub use verify_exit::verify_exit;
 pub use verify_slashable_attestation::verify_slashable_attestation;
-pub use verify_transfer::{execute_transfer, verify_transfer};
+pub use verify_transfer::{execute_transfer, verify_transfer, verify_transfer_partial};
 
 pub mod errors;
 mod validate_attestation;
@@ -426,7 +429,7 @@ pub fn process_exits(
         .par_iter()
         .enumerate()
         .try_for_each(|(i, exit)| {
-            verify_exit(&state, exit, spec).map_err(|e| e.into_with_index(i))
+            verify_exit(&state, exit, spec, true).map_err(|e| e.into_with_index(i))
         })?;
 
     // Update the state in series.

eth2/state_processing/src/per_block_processing/errors.rs

@@ -390,6 +390,11 @@ pub enum TransferInvalid {
     ///
     /// (state_slot, transfer_slot)
     StateSlotMismatch(Slot, Slot),
+    /// The `transfer.slot` is in the past relative to the state slot.
+    ///
+    ///
+    /// (state_slot, transfer_slot)
+    TransferSlotInPast(Slot, Slot),
     /// The `transfer.from` validator has been activated and is not withdrawable.
     ///
     /// (from_validator)

eth2/state_processing/src/per_block_processing/verify_deposit.rs

@@ -89,7 +89,11 @@ pub fn get_existing_validator_index(
 /// Verify that a deposit is included in the state's eth1 deposit root.
 ///
 /// Spec v0.5.0
-fn verify_deposit_merkle_proof(state: &BeaconState, deposit: &Deposit, spec: &ChainSpec) -> bool {
+pub fn verify_deposit_merkle_proof(
+    state: &BeaconState,
+    deposit: &Deposit,
+    spec: &ChainSpec,
+) -> bool {
     let leaf = hash(&get_serialized_deposit_data(deposit));
     verify_merkle_proof(
         Hash256::from_slice(&leaf),

eth2/state_processing/src/per_block_processing/verify_exit.rs

@@ -7,11 +7,17 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `Exit` is valid, otherwise indicates the reason for invalidity.
 ///
+/// The `check_future_epoch` argument determines whether the exit's epoch should be checked
+/// against the state's current epoch to ensure it doesn't occur in the future.
+/// It should ordinarily be set to true, except for operations stored for
+/// some time (such as in the OperationPool).
+///
 /// Spec v0.5.0
 pub fn verify_exit(
     state: &BeaconState,
     exit: &VoluntaryExit,
     spec: &ChainSpec,
+    check_future_epoch: bool,
 ) -> Result<(), Error> {
     let validator = state
         .validator_registry
@@ -32,7 +38,7 @@ pub fn verify_exit(
 
     // Exits must specify an epoch when they become valid; they are not valid before then.
     verify!(
-        state.current_epoch(spec) >= exit.epoch,
+        !check_future_epoch || state.current_epoch(spec) >= exit.epoch,
         Invalid::FutureEpoch {
             state: state.current_epoch(spec),
             exit: exit.epoch

eth2/state_processing/src/per_block_processing/verify_transfer.rs

@@ -15,6 +15,19 @@ pub fn verify_transfer(
     state: &BeaconState,
     transfer: &Transfer,
     spec: &ChainSpec,
+) -> Result<(), Error> {
+    verify_transfer_partial(state, transfer, spec, false)
+}
+
+/// Parametric version of `verify_transfer` that allows some checks to be skipped.
+///
+/// In everywhere except the operation pool, `verify_transfer` should be preferred over this
+/// function.
+pub fn verify_transfer_partial(
+    state: &BeaconState,
+    transfer: &Transfer,
+    spec: &ChainSpec,
+    for_op_pool: bool,
 ) -> Result<(), Error> {
     let sender_balance = *state
         .validator_balances
@@ -27,17 +40,18 @@ pub fn verify_transfer(
         .ok_or_else(|| Error::Invalid(Invalid::FeeOverflow(transfer.amount, transfer.fee)))?;
 
     verify!(
-        sender_balance >= transfer.amount,
+        for_op_pool || sender_balance >= transfer.amount,
         Invalid::FromBalanceInsufficient(transfer.amount, sender_balance)
     );
 
     verify!(
-        sender_balance >= transfer.fee,
+        for_op_pool || sender_balance >= transfer.fee,
         Invalid::FromBalanceInsufficient(transfer.fee, sender_balance)
     );
 
     verify!(
-        (sender_balance == total_amount)
+            for_op_pool
+            || (sender_balance == total_amount)
             || (sender_balance >= (total_amount + spec.min_deposit_amount)),
         Invalid::InvalidResultingFromBalance(
             sender_balance - total_amount,
@@ -45,10 +59,17 @@ pub fn verify_transfer(
         )
     );
 
-    verify!(
-        state.slot == transfer.slot,
-        Invalid::StateSlotMismatch(state.slot, transfer.slot)
-    );
+    if for_op_pool {
+        verify!(
+            state.slot <= transfer.slot,
+            Invalid::TransferSlotInPast(state.slot, transfer.slot)
+        );
+    } else {
+        verify!(
+            state.slot == transfer.slot,
+            Invalid::StateSlotMismatch(state.slot, transfer.slot)
+        );
+    }
 
     let sender_validator = state
         .validator_registry
@@ -57,7 +78,8 @@ pub fn verify_transfer(
     let epoch = state.slot.epoch(spec.slots_per_epoch);
 
     verify!(
-        sender_validator.is_withdrawable_at(epoch)
+        for_op_pool
+            || sender_validator.is_withdrawable_at(epoch)
             || sender_validator.activation_epoch == spec.far_future_epoch,
         Invalid::FromValidatorIneligableForTransfer(transfer.sender)
     );