feat: feynman ts sepolia (#284)

Author: greged93

crates/engine/tree/src/tree/mod.rs

@@ -1207,18 +1207,18 @@ where
         debug!(target: "engine::tree", "received backfill sync finished event");
         self.backfill_sync_state = BackfillSyncState::Idle;
 
-        // backfill height is the block number that the backfill finished at
-        let mut backfill_height = ctrl.block_number();
-
         // Pipeline unwound, memorize the invalid block and wait for CL for next sync target.
-        if let ControlFlow::Unwind { bad_block, target } = &ctrl {
+        let backfill_height = if let ControlFlow::Unwind { bad_block, target } = &ctrl {
             warn!(target: "engine::tree", invalid_block=?bad_block, "Bad block detected in unwind");
             // update the `invalid_headers` cache with the new invalid header
             self.state.invalid_headers.insert(**bad_block);
 
             // if this was an unwind then the target is the new height
-            backfill_height = Some(*target);
-        }
+            Some(*target)
+        } else {
+            // backfill height is the block number that the backfill finished at
+            ctrl.block_number()
+        };
 
         // backfill height is the block number that the backfill finished at
         let Some(backfill_height) = backfill_height else { return Ok(()) };
@@ -1780,20 +1780,18 @@ where
     ) -> Option<B256> {
         let sync_target_state = self.state.forkchoice_state_tracker.sync_target_state();
 
-        // check if the distance exceeds the threshold for backfill sync
-        let mut exceeds_backfill_threshold =
-            self.exceeds_backfill_run_threshold(canonical_tip_num, target_block_number);
-
         // check if the downloaded block is the tracked finalized block
-        if let Some(buffered_finalized) = sync_target_state
+        let mut exceeds_backfill_threshold = if let Some(buffered_finalized) = sync_target_state
             .as_ref()
             .and_then(|state| self.state.buffer.block(&state.finalized_block_hash))
         {
             // if we have buffered the finalized block, we should check how far
             // we're off
-            exceeds_backfill_threshold =
-                self.exceeds_backfill_run_threshold(canonical_tip_num, buffered_finalized.number());
-        }
+            self.exceeds_backfill_run_threshold(canonical_tip_num, buffered_finalized.number())
+        } else {
+            // check if the distance exceeds the threshold for backfill sync
+            self.exceeds_backfill_run_threshold(canonical_tip_num, target_block_number)
+        };
 
         // If this is invoked after we downloaded a block we can check if this block is the
         // finalized block

crates/net/network/src/manager.rs

@@ -842,20 +842,20 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
                     "Session disconnected"
                 );
 
-                let mut reason = None;
-                if let Some(ref err) = error {
+                let reason = if let Some(ref err) = error {
                     // If the connection was closed due to an error, we report
                     // the peer
                     self.swarm.state_mut().peers_mut().on_active_session_dropped(
                         &remote_addr,
                         &peer_id,
                         err,
                     );
-                    reason = err.as_disconnected();
+                    err.as_disconnected()
                 } else {
                     // Gracefully disconnected
                     self.swarm.state_mut().peers_mut().on_active_session_gracefully_closed(peer_id);
-                }
+                    None
+                };
                 self.metrics.closed_sessions.increment(1);
                 self.update_active_connection_metrics();
 

crates/rpc/rpc-builder/src/auth.rs

@@ -68,16 +68,17 @@ impl AuthServerConfig {
             .map_err(|err| RpcError::server_error(err, ServerKind::Auth(socket_addr)))?;
 
         let handle = server.start(module.inner.clone());
-        let mut ipc_handle: Option<jsonrpsee::server::ServerHandle> = None;
 
-        if let Some(ipc_server_config) = ipc_server_config {
+        let ipc_handle = if let Some(ipc_server_config) = ipc_server_config {
             let ipc_endpoint_str = ipc_endpoint
                 .clone()
                 .unwrap_or_else(|| constants::DEFAULT_ENGINE_API_IPC_ENDPOINT.to_string());
             let ipc_server = ipc_server_config.build(ipc_endpoint_str);
             let res = ipc_server.start(module.inner).await?;
-            ipc_handle = Some(res);
-        }
+            Some(res)
+        } else {
+            None
+        };
 
         Ok(AuthServerHandle { handle: Some(handle), local_addr, secret, ipc_endpoint, ipc_handle })
     }

crates/rpc/rpc-eth-api/src/helpers/state.rs

@@ -277,17 +277,15 @@ pub trait LoadState:
     {
         self.spawn_blocking_io(move |this| {
             // first fetch the on chain nonce of the account
-            let on_chain_account_nonce = this
+            let mut next_nonce = this
                 .latest_state()?
                 .account_nonce(&address)
                 .map_err(Self::Error::from_eth_err)?
                 .unwrap_or_default();
 
-            let mut next_nonce = on_chain_account_nonce;
             // Retrieve the highest consecutive transaction for the sender from the transaction pool
-            if let Some(highest_tx) = this
-                .pool()
-                .get_highest_consecutive_transaction_by_sender(address, on_chain_account_nonce)
+            if let Some(highest_tx) =
+                this.pool().get_highest_consecutive_transaction_by_sender(address, next_nonce)
             {
                 // Return the nonce of the highest consecutive transaction + 1
                 next_nonce = highest_tx.nonce().checked_add(1).ok_or_else(|| {

crates/scroll/alloy/hardforks/src/hardfork.rs

@@ -51,8 +51,7 @@ impl ScrollHardfork {
             (Self::DarwinV2, ForkCondition::Timestamp(1724832000)),
             (Self::Euclid, ForkCondition::Timestamp(1741680000)),
             (Self::EuclidV2, ForkCondition::Timestamp(1741852800)),
-            // TODO: update
-            (Self::Feynman, ForkCondition::Timestamp(u64::MAX)),
+            (Self::Feynman, ForkCondition::Timestamp(1753167600)),
         ]
     }
 }

crates/scroll/chainspec/src/lib.rs

@@ -598,11 +598,11 @@ mod tests {
                 ),
                 (
                     Head { number: 4740239, timestamp: 1741852800, ..Default::default() },
-                    ForkId { hash: ForkHash([0x51, 0x7e, 0x0f, 0x1c]), next: 18446744073709551615 },
+                    ForkId { hash: ForkHash([0x51, 0x7e, 0x0f, 0x1c]), next: 1753167600 },
                 ),
                 (
-                    Head { number: 4740239, timestamp: 18446744073709551615, ..Default::default() },
-                    ForkId { hash: ForkHash([0xc8, 0x43, 0x01, 0x5b]), next: 0 },
+                    Head { number: 4740239, timestamp: 1753167600, ..Default::default() },
+                    ForkId { hash: ForkHash([0x19, 0xbb, 0x92, 0xc6]), next: 0 },
                 ),
             ],
         );

crates/scroll/hardforks/src/lib.rs

@@ -64,8 +64,7 @@ pub static SCROLL_SEPOLIA_HARDFORKS: LazyLock<ChainHardforks> = LazyLock::new(||
         (ScrollHardfork::DarwinV2.boxed(), ForkCondition::Timestamp(1724832000)),
         (ScrollHardfork::Euclid.boxed(), ForkCondition::Timestamp(1741680000)),
         (ScrollHardfork::EuclidV2.boxed(), ForkCondition::Timestamp(1741852800)),
-        // TODO: update
-        (ScrollHardfork::Feynman.boxed(), ForkCondition::Timestamp(u64::MAX)),
+        (ScrollHardfork::Feynman.boxed(), ForkCondition::Timestamp(1753167600)),
     ])
 });
 

crates/storage/db-models/src/accounts.rs

@@ -27,10 +27,7 @@ impl reth_codecs::Compact for AccountBeforeTx {
         // for now put full bytes and later compress it.
         buf.put_slice(self.address.as_slice());
 
-        let mut acc_len = 0;
-        if let Some(account) = self.info {
-            acc_len = account.to_compact(buf);
-        }
+        let acc_len = if let Some(account) = self.info { account.to_compact(buf) } else { 0 };
         acc_len + 20
     }
 

crates/transaction-pool/src/pool/txpool.rs

@@ -1354,11 +1354,9 @@ impl<T: PoolTransaction> AllTransactions<T> {
                     }
                 };
             }
-            // tracks the balance if the sender was changed in the block
-            let mut changed_balance = None;
-
+            // track the balance if the sender was changed in the block
             // check if this is a changed account
-            if let Some(info) = changed_accounts.get(&id.sender) {
+            let changed_balance = if let Some(info) = changed_accounts.get(&id.sender) {
                 // discard all transactions with a nonce lower than the current state nonce
                 if id.nonce < info.state_nonce {
                     updates.push(PoolUpdate {
@@ -1384,8 +1382,10 @@ impl<T: PoolTransaction> AllTransactions<T> {
                     }
                 }
 
-                changed_balance = Some(&info.balance);
-            }
+                Some(&info.balance)
+            } else {
+                None
+            };
 
             // If there's a nonce gap, we can shortcircuit, because there's nothing to update yet.
             if tx.state.has_nonce_gap() {

crates/trie/common/benches/prefix_set.rs

@@ -292,6 +292,7 @@ mod implementations {
     }
 
     #[derive(Default)]
+    #[allow(dead_code)]
     pub struct VecBinarySearchWithLastFoundPrefixSet {
         keys: Vec<Nibbles>,
         last_found_idx: usize,