Some preliminary fixes of crates/reth/node and crates/reth/evm

Author: evgenyzdanovich

Cargo.lock

@@ -105,7 +105,7 @@ pub async fn drain(
             .value(U256::from(1));
 
         let gas_price = l2w.get_gas_price().await.unwrap();
-        let gas_estimate = l2w.estimate_gas(&estimate_tx).await.unwrap() as u128;
+        let gas_estimate = l2w.estimate_gas(estimate_tx).await.unwrap() as u128;
 
         let total_fee = gas_estimate * gas_price;
         let max_send_amount = balance.saturating_sub(U256::from(total_fee));

bin/alpen-cli/src/cmd/drain.rs

@@ -22,8 +22,9 @@ use std::collections::hash_map::Entry;
 use alloy_primitives::map::{DefaultHashBuilder, HashMap};
 use anyhow::{anyhow, Result};
 use revm::{
-    db::{AccountState, DbAccount, InMemoryDB},
-    primitives::{AccountInfo, Bytecode},
+    bytecode::Bytecode,
+    database::{AccountState, Cache, DbAccount, InMemoryDB},
+    state::AccountInfo,
 };
 use revm_primitives::alloy_primitives::{Address, Bytes, B256, U256};
 
@@ -142,21 +143,24 @@ impl InMemoryDBHelper for InMemoryDB {
 
         // Return the DB.
         Ok(InMemoryDB {
-            accounts,
-            block_hashes,
+            cache: Cache {
+                accounts,
+                block_hashes,
+                ..Default::default()
+            },
             ..Default::default()
         })
     }
 
     fn get_account_info(&self, address: Address) -> Result<Option<AccountInfo>> {
-        match self.accounts.get(&address) {
+        match self.cache.accounts.get(&address) {
             Some(db_account) => Ok(db_account.info()),
             None => Err(anyhow!("Account not found.")),
         }
     }
 
     fn get_storage_slot(&self, address: Address, index: U256) -> Result<U256> {
-        match self.accounts.get(&address) {
+        match self.cache.accounts.get(&address) {
             Some(account) => match account.storage.get(&index) {
                 Some(value) => Ok(*value),
                 None => match account.account_state {
@@ -171,14 +175,14 @@ impl InMemoryDBHelper for InMemoryDB {
 
     fn storage_keys(&self) -> HashMap<Address, Vec<U256>> {
         let mut out = HashMap::with_hasher(alloy_primitives::map::DefaultHashBuilder::default());
-        for (address, account) in &self.accounts {
+        for (address, account) in &self.cache.accounts {
             out.insert(*address, account.storage.keys().cloned().collect());
         }
         out
     }
 
     fn insert_block_hash(&mut self, block_number: U256, block_hash: B256) {
-        match self.block_hashes.entry(block_number) {
+        match self.cache.block_hashes.entry(block_number) {
             Entry::Occupied(entry) => assert_eq!(&block_hash, entry.get()),
             Entry::Vacant(entry) => {
                 entry.insert(block_hash);

crates/proof-impl/evm-ee-stf/src/db.rs

@@ -26,7 +26,7 @@ use db::InMemoryDBHelper;
 use mpt::keccak;
 pub use primitives::{EvmBlockStfInput, EvmBlockStfOutput};
 use processor::{EvmConfig, EvmProcessor};
-use revm::{primitives::SpecId, InMemoryDB};
+use revm::{database::InMemoryDB, primitives::hardfork::SpecId};
 use revm_primitives::alloy_primitives::B256;
 use utils::generate_exec_update;
 use zkaleido::ZkVmEnv;
@@ -112,7 +112,7 @@ pub fn process_block_transaction_outer(zkvm: &impl ZkVmEnv) {
 
 #[cfg(test)]
 mod tests {
-    use revm::primitives::SpecId;
+    use revm::primitives::hardfork::SpecId;
     use serde::{Deserialize, Serialize};
 
     use super::*;

crates/proof-impl/evm-ee-stf/src/lib.rs

@@ -1,9 +1,12 @@
 use std::collections::HashMap;
 
-use alloy_consensus::{serde_bincode_compat as serde_bincode_compat_header, Header};
+use alloy_consensus::{
+    serde_bincode_compat::{self as serde_bincode_compat_header},
+    transaction::serde_bincode_compat as serde_bincode_compat_tx,
+    EthereumTxEnvelope, Header, TxEip4844,
+};
 use alloy_eips::eip4895::Withdrawal;
 use alpen_reth_primitives::WithdrawalIntent;
-use reth_primitives::TransactionSigned;
 use revm_primitives::alloy_primitives::{Address, Bytes, FixedBytes, B256};
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
@@ -73,9 +76,8 @@ pub struct EvmBlockStfInput {
     pub ancestor_headers: Vec<Header>,
 
     /// A list of transactions to process.
-    // #[serde_as(as = "Vec<serde_bincode_compat::TransactionSigned>")]
-    // https://github.com/paradigmxyz/reth/issues/15751
-    pub transactions: Vec<TransactionSigned>,
+    #[serde_as(as = "Vec<serde_bincode_compat_tx::EthereumTxEnvelope<'_>>")]
+    pub transactions: Vec<EthereumTxEnvelope<TxEip4844>>,
 
     /// A list of withdrawals to process.
     pub withdrawals: Vec<Withdrawal>,

crates/proof-impl/evm-ee-stf/src/primitives.rs

@@ -26,20 +26,18 @@ use alloy_primitives::map::DefaultHashBuilder;
 use alloy_rlp::BufMut;
 use alloy_rpc_types_eth::TransactionTrait;
 use alloy_trie::root::ordered_trie_root_with_encoder;
-use alpen_reth_evm::set_evm_handles;
 use anyhow::anyhow;
 use reth_primitives::{Header, Receipt, Transaction, TransactionSigned};
 use reth_primitives_traits::{constants::MINIMUM_GAS_LIMIT, SignedTransaction};
 use revm::{
-    db::{AccountState, InMemoryDB},
-    interpreter::Host,
-    primitives::{SpecId, TransactTo, TxEnv},
-    Database, DatabaseCommit, Evm,
-};
-use revm_primitives::{
-    alloy_primitives::{Address, Bloom, TxKind as TransactionKind, U256},
-    Account,
+    context::{tx::TxEnv, Evm},
+    context_interface::TransactTo,
+    database::{AccountState, InMemoryDB},
+    primitives::hardfork::SpecId,
+    state::AccountInfo,
+    Database, DatabaseCommit,
 };
+use revm_primitives::alloy_primitives::{Address, Bloom, TxKind as TransactionKind, U256};
 
 use crate::{
     mpt::{keccak, RlpBytes, StateAccount},
@@ -191,7 +189,7 @@ where
                 blk_env.gas_limit = U256::from(self.header.as_mut().unwrap().gas_limit);
             })
             .with_db(self.db.take().unwrap())
-            .append_handler_register(set_evm_handles)
+            //.append_handler_register(set_evm_handles)
             .build();
 
         let mut logs_bloom = Bloom::default();
@@ -282,7 +280,7 @@ impl EvmProcessor<InMemoryDB> {
         let db = self.db.take().expect("DB not initialized");
 
         let mut state_trie = mem::take(&mut self.input.pre_state_trie);
-        for (address, account) in &db.accounts {
+        for (address, account) in &db.cache.accounts {
             // Ignore untouched accounts.
             if account.account_state == AccountState::None {
                 continue;
@@ -357,15 +355,15 @@ fn fill_eth_tx_env(tx_env: &mut TxEnv, essence: &Transaction, caller: Address) {
             tx_env.value = tx.value;
             tx_env.data = tx.input.clone();
             tx_env.chain_id = tx.chain_id;
-            tx_env.nonce = Some(tx.nonce);
+            tx_env.nonce = tx.nonce;
             tx_env.access_list.clear();
         }
         Transaction::Eip2930(tx) => {
             tx_env.caller = caller;
             tx_env.gas_limit = tx.gas_limit;
             tx_env.gas_price = U256::from(tx.gas_price);
             tx_env.gas_priority_fee = None;
-            tx_env.transact_to = if let TransactionKind::Call(to_addr) = tx.to {
+            tx_env.to = if let TransactionKind::Call(to_addr) = tx.to {
                 TransactTo::Call(to_addr)
             } else {
                 TransactTo::Create
@@ -407,7 +405,7 @@ where
     <D as Database>::Error: core::fmt::Debug,
 {
     // Read account from database
-    let mut account: Account = db
+    let mut account: AccountInfo = db
         .basic(address)
         .map_err(|db_err| {
             anyhow!(
@@ -419,7 +417,7 @@ where
         .unwrap_or_default()
         .into();
     // Credit withdrawal amount
-    account.info.balance = account.info.balance.checked_add(amount_wei).unwrap();
+    account.balance = account.balance.checked_add(amount_wei).unwrap();
     account.mark_touch();
     // Commit changes to database
 

crates/proof-impl/evm-ee-stf/src/processor.rs

@@ -1,25 +1,20 @@
 use std::sync::Arc;
 
 use revm::{
-    handler::register::EvmHandler,
-    primitives::{Address, EVMError, SpecId, U256},
-    Context, ContextPrecompile, Database,
+    context::result::EVMError,
+    precompile::{PrecompileWithAddress, Precompiles},
+    primitives::{Address, U256},
+    Context, Database,
 };
-use revm_primitives::Precompile;
 
-use crate::{
-    constants::{BASEFEE_ADDRESS, FIXED_WITHDRAWAL_WEI, SCHNORR_ADDRESS},
-    precompiles::{
-        bridge::{BridgeoutPrecompile, BRIDGEOUT_ADDRESS},
-        schnorr::verify_schnorr_precompile,
-    },
-};
+use crate::{constants::SCHNORR_ADDRESS, precompiles::schnorr::verify_schnorr_precompile};
 
 /// Add rollup specific customizations to EVM
-pub fn set_evm_handles<EXT, DB>(handler: &mut EvmHandler<EXT, DB>)
+pub fn set_evm_handles<EXT, DB>()
 where
     DB: Database,
 {
+    /*
     let spec_id = handler.cfg.spec_id;
 
     // install the precompiles
@@ -54,12 +49,13 @@ where
 
         prev_handle(context, gas)
     })
+    */
 }
 
 enum BalanceUpdate {
     Add(U256),
 }
-
+/*
 fn update_account_balance<EXT, DB: Database>(
     context: &mut Context<EXT, DB>,
     address: Address,
@@ -77,3 +73,14 @@ fn update_account_balance<EXT, DB: Database>(
 
     Ok(())
 }
+*/
+
+pub fn get_precompiles() -> Precompiles {
+    let mut p = Precompiles::default();
+    p.extend([PrecompileWithAddress(
+        SCHNORR_ADDRESS,
+        verify_schnorr_precompile,
+    )]);
+
+    p
+}

crates/reth/evm/src/config.rs

@@ -6,5 +6,5 @@ pub mod constants;
 mod precompiles;
 mod utils;
 
-pub use config::set_evm_handles;
+pub use config::{get_precompiles, set_evm_handles};
 pub use utils::collect_withdrawal_intents;

crates/reth/evm/src/lib.rs

@@ -1,6 +1,6 @@
 use alpen_reth_primitives::WithdrawalIntentEvent;
 use revm::{
-    primitives::{PrecompileError, PrecompileErrors, PrecompileOutput, PrecompileResult},
+    precompile::{PrecompileError, PrecompileOutput, PrecompileResult},
     ContextStatefulPrecompile, Database,
 };
 use revm_primitives::{Bytes, Log, LogData, U256};

crates/reth/evm/src/precompiles/bridge.rs

@@ -1,2 +1,2 @@
-pub mod bridge;
+//pub mod bridge;
 pub mod schnorr;

crates/reth/evm/src/precompiles/mod.rs

@@ -1,7 +1,4 @@
-use revm::{
-    precompile::utilities::right_pad,
-    primitives::{PrecompileOutput, PrecompileResult},
-};
+use revm::precompile::{utilities::right_pad, PrecompileOutput, PrecompileResult};
 use revm_primitives::Bytes;
 use strata_crypto::verify_schnorr_sig;
 use strata_primitives::buf::{Buf32, Buf64};

crates/reth/evm/src/precompiles/schnorr.rs

@@ -45,17 +45,15 @@ where
             }
 
             let txid = Buf32(tx.hash().as_slice().try_into().expect("32 bytes"));
-            WithdrawalIntentEvent::decode_log(log, true)
-                .ok()
-                .and_then(|evt| {
-                    Descriptor::from_bytes(&evt.destination)
-                        .ok()
-                        .map(|destination| WithdrawalIntent {
-                            amt: evt.amount,
-                            destination,
-                            withdrawal_txid: txid,
-                        })
-                })
+            WithdrawalIntentEvent::decode_log(log).ok().and_then(|evt| {
+                Descriptor::from_bytes(&evt.destination)
+                    .ok()
+                    .map(|destination| WithdrawalIntent {
+                        amt: evt.amount,
+                        destination,
+                        withdrawal_txid: txid,
+                    })
+            })
         })
     })
 }

crates/reth/evm/src/utils.rs

@@ -28,42 +28,51 @@ pub struct StrataEngineTypes<T: PayloadTypes = StrataPayloadTypes> {
 
 impl<T: PayloadTypes> PayloadTypes for StrataEngineTypes<T> {
     type BuiltPayload = T::BuiltPayload;
+    type ExecutionData = ExecutionData;
     type PayloadAttributes = T::PayloadAttributes;
     type PayloadBuilderAttributes = T::PayloadBuilderAttributes;
+
+    fn block_to_payload(
+        block: SealedBlock<
+            <<Self::BuiltPayload as BuiltPayload>::Primitives as NodePrimitives>::Block,
+        >,
+    ) -> ExecutionData {
+        let (payload, sidecar) =
+            ExecutionPayload::from_block_unchecked(block.hash(), &block.into_block());
+        ExecutionData { payload, sidecar }
+    }
 }
 
-impl<T: PayloadTypes> EngineTypes for StrataEngineTypes<T>
+impl<T: PayloadTypes<ExecutionData = ExecutionData>> EngineTypes for StrataEngineTypes<T>
 where
     T::BuiltPayload: BuiltPayload<Primitives: NodePrimitives<Block = reth_primitives::Block>>
         + TryInto<ExecutionPayloadV1>
         + TryInto<StrataExecutionPayloadEnvelopeV2>
         + TryInto<ExecutionPayloadEnvelopeV3>
         + TryInto<ExecutionPayloadEnvelopeV4>,
 {
-    type ExecutionData = ExecutionData;
     type ExecutionPayloadEnvelopeV1 = ExecutionPayloadV1;
     type ExecutionPayloadEnvelopeV2 = StrataExecutionPayloadEnvelopeV2;
     type ExecutionPayloadEnvelopeV3 = ExecutionPayloadEnvelopeV3;
     type ExecutionPayloadEnvelopeV4 = ExecutionPayloadEnvelopeV4;
-
-    fn block_to_payload(
-        block: SealedBlock<
-            <<Self::BuiltPayload as BuiltPayload>::Primitives as NodePrimitives>::Block,
-        >,
-    ) -> ExecutionData {
-        let (payload, sidecar) =
-            ExecutionPayload::from_block_unchecked(block.hash(), &block.into_block());
-        ExecutionData { payload, sidecar }
-    }
 }
 
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
-pub struct StrataPayloadTypes;
+pub struct StrataPayloadTypes<N: NodePrimitives = NodePrimitives>;
 
 impl PayloadTypes for StrataPayloadTypes {
+    type ExecutionData = ExecutionData;
     type BuiltPayload = StrataBuiltPayload;
     type PayloadAttributes = StrataPayloadAttributes;
     type PayloadBuilderAttributes = StrataPayloadBuilderAttributes;
+
+    fn block_to_payload(
+        block: SealedBlock<
+            <<Self::BuiltPayload as BuiltPayload>::Primitives as NodePrimitives>::Block,
+        >,
+    ) -> Self::ExecutionData {
+        Self::ExecutionData::from_block_unchecked(block.hash(), &block.into_block())
+    }
 }
 
 /// Strata engine validator