feat: fusaka support (#704)

* feat: fusaka support

* fix blob base fee calculation

* fix clippy

* update checkpoints

* bump version

Author: ncitron

Cargo.lock

@@ -6,7 +6,7 @@ autobenches = false
 exclude = ["benches"]
 
 [workspace.package]
-version = "0.9.0"
+version = "0.9.1"
 
 [workspace]
 members = [
@@ -40,7 +40,7 @@ sha2 = "0.9"
 bls12_381 = { version = "0.8.0", features = ["experimental"] }
 
 # execution
-alloy = { version = "1.0.3", features = [
+alloy = { version = "1.0.37", features = [
     "rpc-types",
     "consensus",
     "rlp",
@@ -52,9 +52,9 @@ alloy = { version = "1.0.3", features = [
     "json-rpc",
     "signers",
 ] }
-alloy-trie = { version = "0.9", features = ["ethereum"] }
-op-alloy-rpc-types = "0.18.0"
-revm = { version = "22.0.1", default-features = false, features = [
+alloy-trie = { version = "0.9.1", features = ["ethereum"] }
+op-alloy-rpc-types = "0.20.0"
+revm = { version = "29.0.1", default-features = false, features = [
     "std",
     "serde",
     "optional_block_gas_limit",
@@ -109,7 +109,7 @@ dotenv = "0.15.0"
 helios-verifiable-api-server = { path = "verifiable-api/server" }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
-alloy = { version = "1.0.3", features = ["full"] }
+alloy = { version = "1.0.37", features = ["full"] }
 tokio = { version = "1", features = ["full"] }
 eyre = "0.6.8"
 dirs = "5.0.1"

Cargo.toml

@@ -21,7 +21,7 @@ pub struct ForkSchedule {
     pub shanghai_timestamp: u64,
     pub cancun_timestamp: u64,
     pub prague_timestamp: u64,
-    // Osaka and beyond TBD
+    pub osaka_timestamp: u64,
 
     // Optimism Forks
     pub bedrock_timestamp: u64,
@@ -56,6 +56,7 @@ impl Default for ForkSchedule {
             shanghai_timestamp: u64::MAX,
             cancun_timestamp: u64::MAX,
             prague_timestamp: u64::MAX,
+            osaka_timestamp: u64::MAX,
 
             bedrock_timestamp: u64::MAX,
             regolith_timestamp: u64::MAX,
@@ -68,3 +69,15 @@ impl Default for ForkSchedule {
         }
     }
 }
+
+impl ForkSchedule {
+    /// Get the blob base fee update fraction for a given timestamp.
+    /// The fraction changes from Cancun to Prague according to EIP-7892.
+    pub fn get_blob_base_fee_update_fraction(&self, timestamp: u64) -> u64 {
+        if timestamp >= self.prague_timestamp {
+            5007716 // Prague and later (EIP-7892)
+        } else {
+            3338477 // Cancun
+        }
+    }
+}

common/src/fork_schedule.rs

@@ -420,8 +420,13 @@ impl<N: NetworkSpec, C: Consensus<N::BlockResponse>, E: ExecutionProvider<N>> He
             .ok_or(eyre!(ClientError::BlockNotFound(block_id)))?;
 
         if let Some(excess_blob_gas) = block.header().excess_blob_gas() {
-            let is_prague = block.header().timestamp() >= self.fork_schedule.prague_timestamp;
-            let price = BlobExcessGasAndPrice::new(excess_blob_gas, is_prague).blob_gasprice;
+            // Get blob base fee update fraction based on fork
+            let blob_base_fee_update_fraction = self
+                .fork_schedule
+                .get_blob_base_fee_update_fraction(block.header().timestamp());
+
+            let price = BlobExcessGasAndPrice::new(excess_blob_gas, blob_base_fee_update_fraction)
+                .blob_gasprice;
             Ok(U256::from(price))
         } else {
             Ok(U256::ZERO)

core/src/client/node.rs

@@ -227,7 +227,12 @@ fn apply_update_no_quorum_check<S: ConsensusSpec>(
             store.optimistic_header = store.finalized_header.clone();
         }
 
-        if store.finalized_header.beacon().slot % S::slots_per_epoch() == 0 {
+        if store
+            .finalized_header
+            .beacon()
+            .slot
+            .is_multiple_of(S::slots_per_epoch())
+        {
             let checkpoint = store.finalized_header.beacon().tree_hash_root();
             return Some(checkpoint);
         }

ethereum/consensus-core/src/consensus_core.rs

@@ -96,7 +96,7 @@ fn is_proof_valid<T: TreeHash>(
     let mut hasher = Sha256::new();
 
     for (i, node) in branch.iter().enumerate() {
-        if (index / 2usize.pow(i as u32)) % 2 != 0 {
+        if !(index / 2usize.pow(i as u32)).is_multiple_of(2) {
             hasher.update(node);
             hasher.update(derived_root);
         } else {

ethereum/consensus-core/src/proof.rs

@@ -586,6 +586,7 @@ pub struct Forks {
     pub capella: Fork,
     pub deneb: Fork,
     pub electra: Fork,
+    pub fusaka: Fork,
 }
 
 #[derive(Serialize, Deserialize, Debug, Default, Clone)]

ethereum/consensus-core/src/types/mod.rs

@@ -183,5 +183,9 @@ fn get_forks(with_electra: bool) -> Forks {
             epoch: if with_electra { 0 } else { u64::MAX },
             fork_version: fixed_bytes!("05000001"),
         },
+        fusaka: Fork {
+            epoch: u64::MAX,
+            fork_version: fixed_bytes!("06000001"),
+        },
     }
 }

ethereum/consensus-core/tests/runner/mod.rs

@@ -78,7 +78,7 @@ impl Network {
 pub fn mainnet() -> BaseConfig {
     BaseConfig {
         default_checkpoint: b256!(
-            "0xe4163704b79dbb52a91ba6be1ae6f5504b060522f5495c73b6c55865412b428c"
+            "9b41a80f58c52068a00e8535b8d6704769c7577a5fd506af5e0c018687991d55"
         ),
         rpc_port: 8545,
         consensus_rpc: Some(Url::parse("https://ethereum.operationsolarstorm.org").unwrap()),
@@ -112,6 +112,10 @@ pub fn mainnet() -> BaseConfig {
                 epoch: 364032,
                 fork_version: fixed_bytes!("05000000"),
             },
+            fusaka: Fork {
+                epoch: 411392,
+                fork_version: fixed_bytes!("06000000"),
+            },
         },
         execution_forks: EthereumForkSchedule::mainnet(),
         max_checkpoint_age: 1_209_600, // 14 days
@@ -124,7 +128,7 @@ pub fn mainnet() -> BaseConfig {
 pub fn sepolia() -> BaseConfig {
     BaseConfig {
         default_checkpoint: b256!(
-            "234931a3fe5d791f06092477357e2d65dcf6fa6cad048680eb93ad3ea494bbcd"
+            "4065c2509eaa15dbe60e1f80cff5205a532aa95aaa1d73c1c286f7f8535555d4"
         ),
         rpc_port: 8545,
         consensus_rpc: None,
@@ -158,6 +162,10 @@ pub fn sepolia() -> BaseConfig {
                 epoch: 222464,
                 fork_version: fixed_bytes!("90000074"),
             },
+            fusaka: Fork {
+                epoch: 272640,
+                fork_version: fixed_bytes!("90000075"),
+            },
         },
         execution_forks: EthereumForkSchedule::sepolia(),
         max_checkpoint_age: 1_209_600, // 14 days
@@ -170,7 +178,7 @@ pub fn sepolia() -> BaseConfig {
 pub fn holesky() -> BaseConfig {
     BaseConfig {
         default_checkpoint: b256!(
-            "bb1f40340606d3b6d6d610b9933b388ddab585fc8898320c29eb771f75c61b48"
+            "e1f575f0b691404fe82cce68a09c2c98af197816de14ce53c0fe9f9bd02d2399"
         ),
         rpc_port: 8545,
         consensus_rpc: None,
@@ -204,6 +212,10 @@ pub fn holesky() -> BaseConfig {
                 epoch: 115968,
                 fork_version: fixed_bytes!("06017000"),
             },
+            fusaka: Fork {
+                epoch: 165120,
+                fork_version: fixed_bytes!("07017000"),
+            },
         },
         execution_forks: EthereumForkSchedule::holesky(),
         max_checkpoint_age: 1_209_600, // 14 days
@@ -216,7 +228,7 @@ pub fn holesky() -> BaseConfig {
 pub fn hoodi() -> BaseConfig {
     BaseConfig {
         default_checkpoint: b256!(
-            "689dc3d39faf53c360ada45a734139bfb195f96d04416c797bb0c1a46da903ad"
+            "3335028555f5fff431f82f978d2503ed59bc8da00a86217eea9befa9d486a049"
         ),
         rpc_port: 8545,
         consensus_rpc: None,
@@ -250,6 +262,10 @@ pub fn hoodi() -> BaseConfig {
                 epoch: 2048,
                 fork_version: fixed_bytes!("60000910"),
             },
+            fusaka: Fork {
+                epoch: 50688,
+                fork_version: fixed_bytes!("70000910"),
+            },
         },
         execution_forks: EthereumForkSchedule::hoodi(),
         max_checkpoint_age: 1_209_600, // 14 days
@@ -290,6 +306,7 @@ impl EthereumForkSchedule {
             shanghai_timestamp: 1681338455,
             cancun_timestamp: 1710338135,
             prague_timestamp: 1746612311,
+            osaka_timestamp: 1764798551,
 
             ..Default::default()
         }
@@ -315,6 +332,7 @@ impl EthereumForkSchedule {
             shanghai_timestamp: 1677557088,
             cancun_timestamp: 1706655072,
             prague_timestamp: 1741159776,
+            osaka_timestamp: 1760427360,
 
             ..Default::default()
         }
@@ -340,6 +358,7 @@ impl EthereumForkSchedule {
             shanghai_timestamp: 1696000704,
             cancun_timestamp: 1707305664,
             prague_timestamp: 1740434112,
+            osaka_timestamp: 1759308480,
 
             ..Default::default()
         }
@@ -365,6 +384,7 @@ impl EthereumForkSchedule {
             shanghai_timestamp: 0,
             cancun_timestamp: 0,
             prague_timestamp: 1742999832,
+            osaka_timestamp: 1761677592,
 
             ..Default::default()
         }

ethereum/src/config/networks.rs

@@ -10,7 +10,7 @@ use eyre::Result;
 use revm::{
     context::{result::ExecutionResult, BlockEnv, CfgEnv, ContextTr, TxEnv},
     context_interface::block::BlobExcessGasAndPrice,
-    primitives::{hardfork::SpecId, Address},
+    primitives::{hardfork::SpecId, Address, U256},
     Context, ExecuteEvm, MainBuilder, MainContext,
 };
 use tracing::debug;
@@ -57,33 +57,33 @@ impl<E: ExecutionProvider<Ethereum>> EthereumEvm<E> {
         let mut db = ProofDB::new(self.block_id, self.execution.clone());
         _ = db.state.prefetch_state(tx, validate_tx).await;
 
-        let mut evm = self
-            .get_context(tx, self.block_id, validate_tx)
-            .await?
-            .with_db(db)
-            .build_mainnet();
-
-        let tx_res = loop {
-            let db = evm.db();
-            if db.state.needs_update() {
-                debug!("evm cache miss: {:?}", db.state.access.as_ref().unwrap());
-                db.state
-                    .update_state()
-                    .await
-                    .map_err(|e| EvmError::Generic(e.to_string()))?;
+        // Pre-fetch all required state
+        loop {
+            if !db.state.needs_update() {
+                break;
             }
+            debug!("evm cache miss: {:?}", db.state.access.as_ref().unwrap());
+            db.state
+                .update_state()
+                .await
+                .map_err(|e| EvmError::Generic(e.to_string()))?;
+        }
 
-            let res = evm.replay();
-
-            let db = evm.db();
-            let needs_update = db.state.needs_update();
+        // Now execute synchronously with all state loaded
+        let context = self.get_context(tx, self.block_id, validate_tx).await?;
 
-            if res.is_ok() || !needs_update {
-                break res.map(|res| (res.result, mem::take(&mut db.state.accounts)));
-            }
+        // Execute in a scope to ensure EVM is dropped before any async operations
+        let (result, accounts) = {
+            let mut evm = context.with_db(db).build_mainnet();
+            let res = evm.replay();
+            let db = evm.db_mut();
+            let accounts = mem::take(&mut db.state.accounts);
+            (res, accounts)
         };
 
-        tx_res.map_err(|err| EvmError::Generic(format!("generic: {err}")))
+        result
+            .map(|r| (r.result, accounts))
+            .map_err(|err| EvmError::Generic(format!("generic: {err}")))
     }
 
     async fn get_context(
@@ -157,17 +157,20 @@ impl<E: ExecutionProvider<Ethereum>> EthereumEvm<E> {
     }
 
     fn block_env(block: &Block<Transaction, Header>, fork_schedule: &ForkSchedule) -> BlockEnv {
-        let is_prague = block.header.timestamp >= fork_schedule.prague_timestamp;
+        // Get blob base fee update fraction based on fork
+        let blob_base_fee_update_fraction =
+            fork_schedule.get_blob_base_fee_update_fraction(block.header.timestamp());
+
         let blob_excess_gas_and_price = block
             .header
             .excess_blob_gas()
-            .map(|v| BlobExcessGasAndPrice::new(v, is_prague))
-            .unwrap_or_else(|| BlobExcessGasAndPrice::new(0, is_prague));
+            .map(|v| BlobExcessGasAndPrice::new(v, blob_base_fee_update_fraction))
+            .unwrap_or_else(|| BlobExcessGasAndPrice::new(0, blob_base_fee_update_fraction));
 
         BlockEnv {
-            number: block.header.number(),
+            number: U256::from(block.header.number()),
             beneficiary: block.header.beneficiary(),
-            timestamp: block.header.timestamp(),
+            timestamp: U256::from(block.header.timestamp()),
             gas_limit: block.header.gas_limit(),
             basefee: block.header.base_fee_per_gas().unwrap_or_default(),
             difficulty: block.header.difficulty(),
@@ -178,7 +181,9 @@ impl<E: ExecutionProvider<Ethereum>> EthereumEvm<E> {
 }
 
 pub fn get_spec_id_for_block_timestamp(timestamp: u64, fork_schedule: &ForkSchedule) -> SpecId {
-    if timestamp >= fork_schedule.prague_timestamp {
+    if timestamp >= fork_schedule.osaka_timestamp {
+        SpecId::OSAKA
+    } else if timestamp >= fork_schedule.prague_timestamp {
         SpecId::PRAGUE
     } else if timestamp >= fork_schedule.cancun_timestamp {
         SpecId::CANCUN