Revert "only increment deposit index on state for old deposit flow"

This reverts commit 817d4235ae.

beacon_node/beacon_chain/src/eth1_chain.rs

@@ -549,7 +549,6 @@ impl<E: EthSpec> Eth1ChainBackend<E> for CachingEth1Backend<E> {
         // [New in Electra:EIP6110]
         let deposit_index_limit =
             if let Ok(deposit_receipts_start_index) = state.deposit_receipts_start_index() {
-                dbg!("deposit_receipts_start_index", deposit_receipts_start_index);
                 std::cmp::min(deposit_count, deposit_receipts_start_index)
             } else {
                 deposit_count
@@ -562,14 +561,6 @@ impl<E: EthSpec> Eth1ChainBackend<E> for CachingEth1Backend<E> {
                 let next = deposit_index;
                 let last = std::cmp::min(deposit_index_limit, next + E::MaxDeposits::to_u64());
 
-                dbg!(
-                    next,
-                    last,
-                    deposit_count,
-                    deposit_index_limit,
-                    E::MaxDeposits::to_u64()
-                );
-
                 self.core
                     .deposits()
                     .read()

beacon_node/genesis/src/eth1_genesis_service.rs

@@ -439,7 +439,7 @@ impl Eth1GenesisService {
                     None
                 };
 
-                apply_deposit(&mut state, data, proof, true, spec)
+                apply_deposit(&mut state, data, proof, spec)
                     .map_err(|e| format!("Error whilst processing deposit: {:?}", e))
             })?;
 

consensus/state_processing/src/genesis.rs

@@ -38,7 +38,7 @@ pub fn initialize_beacon_state_from_eth1<E: EthSpec>(
             .map_err(BlockProcessingError::MerkleTreeError)?;
         state.eth1_data_mut().deposit_root = deposit_tree.root();
         let Deposit { proof, data } = deposit;
-        apply_deposit(&mut state, data, Some(proof), true, spec)?;
+        apply_deposit(&mut state, data, Some(proof), spec)?;
     }
 
     process_activations(&mut state, spec)?;

consensus/state_processing/src/per_block_processing/process_operations.rs

@@ -417,7 +417,7 @@ pub fn process_deposits<E: EthSpec>(
 
     // Update the state in series.
     for deposit in deposits {
-        apply_deposit(state, deposit.data.clone(), None, true, spec)?;
+        apply_deposit(state, deposit.data.clone(), None, spec)?;
     }
 
     Ok(())
@@ -428,7 +428,6 @@ pub fn apply_deposit<E: EthSpec>(
     state: &mut BeaconState<E>,
     deposit_data: DepositData,
     proof: Option<FixedVector<Hash256, U33>>,
-    increment_deposit_index: bool,
     spec: &ChainSpec,
 ) -> Result<(), BlockProcessingError> {
     let deposit_index = state.eth1_deposit_index() as usize;
@@ -441,9 +440,7 @@ pub fn apply_deposit<E: EthSpec>(
             .map_err(|e| e.into_with_index(deposit_index))?;
     }
 
-    if increment_deposit_index {
+    state.eth1_deposit_index_mut().safe_add_assign(1)?;
-        state.eth1_deposit_index_mut().safe_add_assign(1)?;
-    }
 
     // Get an `Option<u64>` where `u64` is the validator index if this deposit public key
     // already exists in the beacon_state.
@@ -462,12 +459,6 @@ pub fn apply_deposit<E: EthSpec>(
                 .get(index as usize)
                 .ok_or(BeaconStateError::UnknownValidator(index as usize))?;
 
-            dbg!(is_compounding_withdrawal_credential(
-                deposit_data.withdrawal_credentials,
-                spec
-            ));
-            dbg!(validator.has_eth1_withdrawal_credential(spec));
-            dbg!(is_valid_deposit_signature(&deposit_data, spec).is_ok());
             if is_compounding_withdrawal_credential(deposit_data.withdrawal_credentials, spec)
                 && validator.has_eth1_withdrawal_credential(spec)
                 && is_valid_deposit_signature(&deposit_data, spec).is_ok()
@@ -500,8 +491,6 @@ pub fn apply_deposit<E: EthSpec>(
                 amount,
             )
         };
-        dbg!(effective_balance, state_balance);
-        dbg!(&deposit_data.pubkey, &deposit_data.withdrawal_credentials);
         // Create a new validator.
         let validator = Validator {
             pubkey: deposit_data.pubkey,
@@ -529,7 +518,6 @@ pub fn apply_deposit<E: EthSpec>(
 
         // [New in Electra:EIP7251]
         if let Ok(pending_balance_deposits) = state.pending_balance_deposits_mut() {
-            dbg!(new_validator_index, amount);
             pending_balance_deposits.push(PendingBalanceDeposit {
                 index: new_validator_index as u64,
                 amount,
@@ -653,7 +641,7 @@ pub fn process_deposit_receipts<E: EthSpec>(
             amount: receipt.amount,
             signature: receipt.signature.clone().into(),
         };
-        apply_deposit(state, deposit_data, None, false, spec)?
+        apply_deposit(state, deposit_data, None, spec)?
     }
 
     Ok(())

consensus/types/src/beacon_state.rs

@@ -2151,7 +2151,6 @@ impl<E: EthSpec> BeaconState<E> {
         if *balance > spec.min_activation_balance {
             let excess_balance = balance.safe_sub(spec.min_activation_balance)?;
             *balance = spec.min_activation_balance;
-            dbg!(validator_index, excess_balance);
             self.pending_balance_deposits_mut()?
                 .push(PendingBalanceDeposit {
                     index: validator_index as u64,
@@ -2201,7 +2200,6 @@ impl<E: EthSpec> BeaconState<E> {
         if validator.has_eth1_withdrawal_credential(spec) {
             validator.withdrawal_credentials.as_fixed_bytes_mut()[0] =
                 spec.compounding_withdrawal_prefix_byte;
-            dbg!(validator.withdrawal_credentials);
             self.queue_excess_active_balance(validator_index, spec)?;
         }
         Ok(())

testing/ef_tests/src/cases/operations.rs

@@ -171,9 +171,7 @@ impl<E: EthSpec> Operation<E> for Deposit {
         spec: &ChainSpec,
         _: &Operations<E, Self>,
     ) -> Result<(), BlockProcessingError> {
-        let res = process_deposits(state, &[self.clone()], spec);
+        process_deposits(state, &[self.clone()], spec)
-        dbg!(serde_json::to_string(state).unwrap());
-        res
     }
 }
 

testing/ef_tests/src/cases/sanity_blocks.rs

@@ -60,9 +60,6 @@ impl<E: EthSpec> Case for SanityBlocks<E> {
     }
 
     fn result(&self, _case_index: usize, fork_name: ForkName) -> Result<(), Error> {
-        if _case_index != 74 || fork_name != ForkName::Electra {
-            return Ok(());
-        }
         self.metadata.bls_setting.unwrap_or_default().check()?;
 
         let mut bulk_state = self.pre.clone();
@@ -114,15 +111,13 @@ impl<E: EthSpec> Case for SanityBlocks<E> {
                     spec,
                 )?;
 
-                // if block.state_root() == bulk_state.update_tree_hash_cache().unwrap()
+                if block.state_root() == bulk_state.update_tree_hash_cache().unwrap()
-                //     && block.state_root() == indiv_state.update_tree_hash_cache().unwrap()
+                    && block.state_root() == indiv_state.update_tree_hash_cache().unwrap()
-                // {
+                {
-                //     Ok(())
+                    Ok(())
-                // } else {
+                } else {
-                //     Err(BlockProcessingError::StateRootMismatch)
+                    Err(BlockProcessingError::StateRootMismatch)
-                // }
+                }
-
-                Ok::<_, BlockProcessingError>(())
             })
             .map(|_| (bulk_state, indiv_state));