diff --git a/Cargo.lock b/Cargo.lock index cf2be38f51c0..735c21a6bd76 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -523,9 +523,9 @@ dependencies = [ [[package]] name = "async-trait" -version = "0.1.73" +version = "0.1.74" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc00ceb34980c03614e35a3a4e218276a0a824e911d07651cd0d858a51e8c0f0" +checksum = "a66537f1bb974b254c98ed142ff995236e81b9d0fe4db0575f46612cb15eb0f9" dependencies = [ "proc-macro2", "quote", @@ -573,6 +573,16 @@ dependencies = [ "wildmatch", ] +[[package]] +name = "aurora-engine-modexp" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfacad86e9e138fca0670949eb8ed4ffdf73a55bded8887efe0863cd1a3a6f70" +dependencies = [ + "hex", + "num", +] + [[package]] name = "auto_impl" version = "1.1.0" @@ -6465,8 +6475,7 @@ dependencies = [ [[package]] name = "revm" version = "3.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68f4ca8ae0345104523b4af1a8a7ea97cfa1865cdb7a7c25d23c1a18d9b48598" +source = "git+https://github.com/bluealloy/revm?rev=68f78ae0a4c2b351f2fe36236164d07933d0d4d5#68f78ae0a4c2b351f2fe36236164d07933d0d4d5" dependencies = [ "auto_impl", "revm-interpreter", @@ -6476,8 +6485,7 @@ dependencies = [ [[package]] name = "revm-interpreter" version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f959cafdf64a7f89b014fa73dc2325001cf654b3d9400260b212d19a2ebe3da0" +source = "git+https://github.com/bluealloy/revm?rev=68f78ae0a4c2b351f2fe36236164d07933d0d4d5#68f78ae0a4c2b351f2fe36236164d07933d0d4d5" dependencies = [ "revm-primitives", ] @@ -6485,12 +6493,11 @@ dependencies = [ [[package]] name = "revm-precompile" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d360a88223d85709d2e95d4609eb1e19c649c47e28954bfabae5e92bb37e83e" +source = "git+https://github.com/bluealloy/revm?rev=68f78ae0a4c2b351f2fe36236164d07933d0d4d5#68f78ae0a4c2b351f2fe36236164d07933d0d4d5" dependencies = [ + "aurora-engine-modexp", "c-kzg", "k256", - "num", "once_cell", "revm-primitives", "ripemd", @@ -6502,8 +6509,7 @@ dependencies = [ [[package]] name = "revm-primitives" version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "51187b852d9e458816a2e19c81f1dd6c924077e1a8fccd16e4f044f865f299d7" +source = "git+https://github.com/bluealloy/revm?rev=68f78ae0a4c2b351f2fe36236164d07933d0d4d5#68f78ae0a4c2b351f2fe36236164d07933d0d4d5" dependencies = [ "alloy-primitives", "alloy-rlp", diff --git a/Cargo.toml b/Cargo.toml index 4db0a74adacb..367f918a3c9f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -109,8 +109,8 @@ reth-ecies = { path = "./crates/net/ecies" } reth-tracing = { path = "./crates/tracing" } # revm -revm = "3.5.0" -revm-primitives = "1.3.0" +revm = { git = "https://github.com/bluealloy/revm", rev = "68f78ae0a4c2b351f2fe36236164d07933d0d4d5" } +revm-primitives = { git = "https://github.com/bluealloy/revm", rev = "68f78ae0a4c2b351f2fe36236164d07933d0d4d5" } ## eth alloy-primitives = "0.4" diff --git a/crates/payload/builder/src/database.rs b/crates/payload/builder/src/database.rs index 8cf0a458b499..2631503cd489 100644 --- a/crates/payload/builder/src/database.rs +++ b/crates/payload/builder/src/database.rs @@ -62,7 +62,7 @@ impl<'a, DB: DatabaseRef> Database for CachedReadsDbMut<'a, DB> { let basic = match self.cached.accounts.entry(address) { Entry::Occupied(entry) => entry.get().info.clone(), Entry::Vacant(entry) => { - entry.insert(CachedAccount::new(self.db.basic(address)?)).info.clone() + entry.insert(CachedAccount::new(self.db.basic_ref(address)?)).info.clone() } }; Ok(basic) @@ -71,7 +71,7 @@ impl<'a, DB: DatabaseRef> Database for CachedReadsDbMut<'a, DB> { fn code_by_hash(&mut self, code_hash: B256) -> Result { let code = match self.cached.contracts.entry(code_hash) { Entry::Occupied(entry) => entry.get().clone(), - Entry::Vacant(entry) => entry.insert(self.db.code_by_hash(code_hash)?).clone(), + Entry::Vacant(entry) => entry.insert(self.db.code_by_hash_ref(code_hash)?).clone(), }; Ok(code) } @@ -83,7 +83,7 @@ impl<'a, DB: DatabaseRef> Database for CachedReadsDbMut<'a, DB> { match acc_entry.storage.entry(index) { Entry::Occupied(entry) => Ok(*entry.get()), Entry::Vacant(entry) => { - let slot = self.db.storage(address, index)?; + let slot = self.db.storage_ref(address, index)?; entry.insert(slot); Ok(slot) } @@ -91,9 +91,9 @@ impl<'a, DB: DatabaseRef> Database for CachedReadsDbMut<'a, DB> { } Entry::Vacant(acc_entry) => { // acc needs to be loaded for us to access slots. - let info = self.db.basic(address)?; + let info = self.db.basic_ref(address)?; let (account, value) = if info.is_some() { - let value = self.db.storage(address, index)?; + let value = self.db.storage_ref(address, index)?; let mut account = CachedAccount::new(info); account.storage.insert(index, value); (account, value) @@ -109,7 +109,7 @@ impl<'a, DB: DatabaseRef> Database for CachedReadsDbMut<'a, DB> { fn block_hash(&mut self, number: U256) -> Result { let code = match self.cached.block_hashes.entry(number) { Entry::Occupied(entry) => *entry.get(), - Entry::Vacant(entry) => *entry.insert(self.db.block_hash(number)?), + Entry::Vacant(entry) => *entry.insert(self.db.block_hash_ref(number)?), }; Ok(code) } @@ -127,19 +127,19 @@ pub struct CachedReadsDBRef<'a, DB> { impl<'a, DB: DatabaseRef> DatabaseRef for CachedReadsDBRef<'a, DB> { type Error = ::Error; - fn basic(&self, address: Address) -> Result, Self::Error> { + fn basic_ref(&self, address: Address) -> Result, Self::Error> { self.inner.borrow_mut().basic(address) } - fn code_by_hash(&self, code_hash: B256) -> Result { + fn code_by_hash_ref(&self, code_hash: B256) -> Result { self.inner.borrow_mut().code_by_hash(code_hash) } - fn storage(&self, address: Address, index: U256) -> Result { + fn storage_ref(&self, address: Address, index: U256) -> Result { self.inner.borrow_mut().storage(address, index) } - fn block_hash(&self, number: U256) -> Result { + fn block_hash_ref(&self, number: U256) -> Result { self.inner.borrow_mut().block_hash(number) } } diff --git a/crates/primitives/src/contract.rs b/crates/primitives/src/contract.rs deleted file mode 100644 index 0464bc96af4b..000000000000 --- a/crates/primitives/src/contract.rs +++ /dev/null @@ -1,105 +0,0 @@ -//! Helpers for deriving contract addresses - -// re-export from revm -use crate::{keccak256, Address, U256}; -pub use revm_primitives::utilities::{create2_address, create_address}; - -/// Returns the CREATE2 address of a smart contract as specified in -/// [EIP1014](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1014.md) -/// -/// keccak256( 0xff ++ senderAddress ++ salt ++ keccak256(init_code))[12..] -/// -/// where `salt` is always 32 bytes (a stack item). -pub fn create2_address_from_code( - from: Address, - init_code: impl AsRef<[u8]>, - salt: U256, -) -> Address { - let init_code_hash = keccak256(init_code); - create2_address(from, init_code_hash, salt) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::hex; - - #[test] - fn contract_address() { - // http://ethereum.stackexchange.com/questions/760/how-is-the-address-of-an-ethereum-contract-computed - let from = "6ac7ea33f8831ea9dcc53393aaa88b25a785dbf0".parse::
().unwrap(); - for (nonce, expected) in [ - "cd234a471b72ba2f1ccf0a70fcaba648a5eecd8d", - "343c43a37d37dff08ae8c4a11544c718abb4fcf8", - "f778b86fa74e846c4f0a1fbd1335fe81c00a0c91", - "fffd933a0bc612844eaf0c6fe3e5b8e9b6c1d19c", - ] - .iter() - .enumerate() - { - let address = create_address(from, nonce as u64); - assert_eq!(address, expected.parse::
().unwrap()); - } - } - - // Test vectors from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1014.md#examples - #[test] - fn test_create2_address() { - for (from, salt, init_code, expected) in &[ - ( - "0000000000000000000000000000000000000000", - "0000000000000000000000000000000000000000000000000000000000000000", - "00", - "4D1A2e2bB4F88F0250f26Ffff098B0b30B26BF38", - ), - ( - "deadbeef00000000000000000000000000000000", - "0000000000000000000000000000000000000000000000000000000000000000", - "00", - "B928f69Bb1D91Cd65274e3c79d8986362984fDA3", - ), - ( - "deadbeef00000000000000000000000000000000", - "000000000000000000000000feed000000000000000000000000000000000000", - "00", - "D04116cDd17beBE565EB2422F2497E06cC1C9833", - ), - ( - "0000000000000000000000000000000000000000", - "0000000000000000000000000000000000000000000000000000000000000000", - "deadbeef", - "70f2b2914A2a4b783FaEFb75f459A580616Fcb5e", - ), - ( - "00000000000000000000000000000000deadbeef", - "00000000000000000000000000000000000000000000000000000000cafebabe", - "deadbeef", - "60f3f640a8508fC6a86d45DF051962668E1e8AC7", - ), - ( - "00000000000000000000000000000000deadbeef", - "00000000000000000000000000000000000000000000000000000000cafebabe", - "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef", - "1d8bfDC5D46DC4f61D6b6115972536eBE6A8854C", - ), - ( - "0000000000000000000000000000000000000000", - "0000000000000000000000000000000000000000000000000000000000000000", - "", - "E33C0C7F7df4809055C3ebA6c09CFe4BaF1BD9e0", - ), - ] { - // create2_address() - let from = from.parse::
().unwrap(); - let salt = hex::decode(salt).unwrap(); - let salt = U256::try_from_be_slice(&salt).unwrap(); - let init_code = hex::decode(init_code).unwrap(); - let expected = expected.parse::
().unwrap(); - assert_eq!(expected, create2_address_from_code(from, init_code.clone(), salt)); - - // get_create2_address_from_hash() - let init_code_hash = keccak256(init_code); - assert_eq!(expected, create2_address(from, init_code_hash, salt)) - } - } -} diff --git a/crates/primitives/src/lib.rs b/crates/primitives/src/lib.rs index 538181445339..309dd2cb1d63 100644 --- a/crates/primitives/src/lib.rs +++ b/crates/primitives/src/lib.rs @@ -23,7 +23,6 @@ mod block; mod chain; mod compression; pub mod constants; -pub mod contract; pub mod eip4844; mod forkid; pub mod fs; diff --git a/crates/revm/revm-inspectors/src/access_list.rs b/crates/revm/revm-inspectors/src/access_list.rs index 738870317432..77016e7b5e02 100644 --- a/crates/revm/revm-inspectors/src/access_list.rs +++ b/crates/revm/revm-inspectors/src/access_list.rs @@ -63,7 +63,7 @@ where { fn step( &mut self, - interpreter: &mut Interpreter, + interpreter: &mut Interpreter<'_>, _data: &mut EVMData<'_, DB>, ) -> InstructionResult { match interpreter.current_opcode() { diff --git a/crates/revm/revm-inspectors/src/stack/maybe_owned.rs b/crates/revm/revm-inspectors/src/stack/maybe_owned.rs index 68848940d958..71b9c53f6ea8 100644 --- a/crates/revm/revm-inspectors/src/stack/maybe_owned.rs +++ b/crates/revm/revm-inspectors/src/stack/maybe_owned.rs @@ -71,7 +71,7 @@ where { fn initialize_interp( &mut self, - interp: &mut Interpreter, + interp: &mut Interpreter<'_>, data: &mut EVMData<'_, DB>, ) -> InstructionResult { match self { @@ -84,7 +84,11 @@ where InstructionResult::Continue } - fn step(&mut self, interp: &mut Interpreter, data: &mut EVMData<'_, DB>) -> InstructionResult { + fn step( + &mut self, + interp: &mut Interpreter<'_>, + data: &mut EVMData<'_, DB>, + ) -> InstructionResult { match self { MaybeOwnedInspector::Owned(insp) => return insp.borrow_mut().step(interp, data), MaybeOwnedInspector::Stacked(_) => {} @@ -110,14 +114,11 @@ where fn step_end( &mut self, - interp: &mut Interpreter, + interp: &mut Interpreter<'_>, data: &mut EVMData<'_, DB>, - eval: InstructionResult, ) -> InstructionResult { match self { - MaybeOwnedInspector::Owned(insp) => { - return insp.borrow_mut().step_end(interp, data, eval) - } + MaybeOwnedInspector::Owned(insp) => return insp.borrow_mut().step_end(interp, data), MaybeOwnedInspector::Stacked(_) => {} } diff --git a/crates/revm/revm-inspectors/src/stack/mod.rs b/crates/revm/revm-inspectors/src/stack/mod.rs index 5e3c9f6677ee..99d756cd5d18 100644 --- a/crates/revm/revm-inspectors/src/stack/mod.rs +++ b/crates/revm/revm-inspectors/src/stack/mod.rs @@ -102,7 +102,7 @@ where { fn initialize_interp( &mut self, - interpreter: &mut Interpreter, + interpreter: &mut Interpreter<'_>, data: &mut EVMData<'_, DB>, ) -> InstructionResult { call_inspectors!(inspector, [&mut self.custom_print_tracer], { @@ -119,7 +119,7 @@ where fn step( &mut self, - interpreter: &mut Interpreter, + interpreter: &mut Interpreter<'_>, data: &mut EVMData<'_, DB>, ) -> InstructionResult { call_inspectors!(inspector, [&mut self.custom_print_tracer], { @@ -148,12 +148,11 @@ where fn step_end( &mut self, - interpreter: &mut Interpreter, + interpreter: &mut Interpreter<'_>, data: &mut EVMData<'_, DB>, - eval: InstructionResult, ) -> InstructionResult { call_inspectors!(inspector, [&mut self.custom_print_tracer], { - let status = inspector.step_end(interpreter, data, eval); + let status = inspector.step_end(interpreter, data); // Allow inspectors to exit early if status != InstructionResult::Continue { diff --git a/crates/revm/revm-inspectors/src/tracing/builder/geth.rs b/crates/revm/revm-inspectors/src/tracing/builder/geth.rs index d40cc032a700..d9da05cfd1b8 100644 --- a/crates/revm/revm-inspectors/src/tracing/builder/geth.rs +++ b/crates/revm/revm-inspectors/src/tracing/builder/geth.rs @@ -193,7 +193,7 @@ impl GethTraceBuilder { if !is_diff { let mut prestate = PreStateMode::default(); for (addr, _) in account_diffs { - let db_acc = db.basic(addr)?.unwrap_or_default(); + let db_acc = db.basic_ref(addr)?.unwrap_or_default(); prestate.0.insert( addr, @@ -210,7 +210,7 @@ impl GethTraceBuilder { let mut state_diff = DiffMode::default(); let mut change_types = HashMap::with_capacity(account_diffs.len()); for (addr, changed_acc) in account_diffs { - let db_acc = db.basic(addr)?.unwrap_or_default(); + let db_acc = db.basic_ref(addr)?.unwrap_or_default(); let db_code = db_acc.code.as_ref(); let db_code_hash = db_acc.code_hash; @@ -223,7 +223,7 @@ impl GethTraceBuilder { if db_code_hash == KECCAK_EMPTY { None } else { - db.code_by_hash(db_code_hash).ok().map(|code| code.original_bytes()) + db.code_by_hash_ref(db_code_hash).ok().map(|code| code.original_bytes()) } }) .map(Into::into); diff --git a/crates/revm/revm-inspectors/src/tracing/builder/parity.rs b/crates/revm/revm-inspectors/src/tracing/builder/parity.rs index 75fee402950e..a418666313ff 100644 --- a/crates/revm/revm-inspectors/src/tracing/builder/parity.rs +++ b/crates/revm/revm-inspectors/src/tracing/builder/parity.rs @@ -385,7 +385,10 @@ impl ParityTraceBuilder { let maybe_memory = if step.memory.is_empty() { None } else { - Some(MemoryDelta { off: step.memory_size, data: step.memory.data().clone().into() }) + Some(MemoryDelta { + off: step.memory_size, + data: step.memory.slice(0, step.memory.len()).to_vec().into(), + }) }; // Calculate the stack items at this step @@ -549,11 +552,11 @@ where let addr = addrs.next().expect("there should be an address"); - let db_acc = db.basic(addr)?.unwrap_or_default(); + let db_acc = db.basic_ref(addr)?.unwrap_or_default(); let code_hash = if db_acc.code_hash != KECCAK_EMPTY { db_acc.code_hash } else { continue }; - curr_ref.code = db.code_by_hash(code_hash)?.original_bytes(); + curr_ref.code = db.code_by_hash_ref(code_hash)?.original_bytes(); } Ok(()) @@ -591,7 +594,8 @@ where } } else { // account already exists, we need to fetch the account from the db - let db_acc = db.basic(addr)?.unwrap_or_default(); + let db_acc = db.basic_ref(addr)?.unwrap_or_default(); + entry.balance = if db_acc.balance == changed_acc.info.balance { Delta::Unchanged } else { diff --git a/crates/revm/revm-inspectors/src/tracing/js/bindings.rs b/crates/revm/revm-inspectors/src/tracing/js/bindings.rs index e077e5583041..25d4cfc96274 100644 --- a/crates/revm/revm-inspectors/src/tracing/js/bindings.rs +++ b/crates/revm/revm-inspectors/src/tracing/js/bindings.rs @@ -20,7 +20,7 @@ use reth_primitives::{Account, Address, Bytes, B256, KECCAK_EMPTY, U256}; use revm::{ interpreter::{ opcode::{PUSH0, PUSH32}, - Memory, OpCode, Stack, + OpCode, SharedMemory, Stack, }, primitives::State, }; @@ -132,14 +132,14 @@ impl StepLog { /// Represents the memory object #[derive(Debug)] -pub(crate) struct MemoryObj(pub(crate) Memory); +pub(crate) struct MemoryObj(pub(crate) SharedMemory); impl MemoryObj { pub(crate) fn into_js_object(self, context: &mut Context<'_>) -> JsResult { let obj = JsObject::default(); let len = self.0.len(); // TODO: add into data - let value = to_buf(self.0.data().clone(), context)?; + let value = to_buf(self.0.slice(0, len).to_vec(), context)?; let length = FunctionObjectBuilder::new( context, diff --git a/crates/revm/revm-inspectors/src/tracing/js/builtins.rs b/crates/revm/revm-inspectors/src/tracing/js/builtins.rs index b3988974e4f4..eee817a78d33 100644 --- a/crates/revm/revm-inspectors/src/tracing/js/builtins.rs +++ b/crates/revm/revm-inspectors/src/tracing/js/builtins.rs @@ -6,10 +6,7 @@ use boa_engine::{ Context, JsArgs, JsError, JsNativeError, JsResult, JsString, JsValue, NativeFunction, Source, }; use boa_gc::{empty_trace, Finalize, Trace}; -use reth_primitives::{ - contract::{create2_address_from_code, create_address}, - hex, keccak256, Address, B256, U256, -}; +use reth_primitives::{hex, Address, B256, U256}; use std::collections::HashSet; /// bigIntegerJS is the minified version of . @@ -161,11 +158,9 @@ pub(crate) fn to_contract2( // Convert the initcode to a byte buffer let code_buf = from_buf(initcode, ctx)?; - // Compute the code hash - let code_hash = keccak256(code_buf); // Compute the contract address - let contract_addr = create2_address_from_code(addr, salt, code_hash.into()); + let contract_addr = addr.create2_from_code(salt, code_buf); // Convert the contract address to a byte buffer and return it as an ArrayBuffer to_buf_value(contract_addr.0.to_vec(), ctx) @@ -186,7 +181,7 @@ pub(crate) fn to_contract( let addr = bytes_to_address(buf); // Compute the contract address - let contract_addr = create_address(addr, nonce); + let contract_addr = addr.create(nonce); // Convert the contract address to a byte buffer and return it as an ArrayBuffer to_buf_value(contract_addr.0.to_vec(), ctx) diff --git a/crates/revm/revm-inspectors/src/tracing/js/mod.rs b/crates/revm/revm-inspectors/src/tracing/js/mod.rs index bc07b72756ce..3b9d4a83d849 100644 --- a/crates/revm/revm-inspectors/src/tracing/js/mod.rs +++ b/crates/revm/revm-inspectors/src/tracing/js/mod.rs @@ -13,9 +13,7 @@ use crate::tracing::{ use boa_engine::{Context, JsError, JsObject, JsResult, JsValue, Source}; use reth_primitives::{Account, Address, Bytes, B256, U256}; use revm::{ - interpreter::{ - return_revert, CallInputs, CallScheme, CreateInputs, Gas, InstructionResult, Interpreter, - }, + interpreter::{CallInputs, CallScheme, CreateInputs, Gas, InstructionResult, Interpreter}, precompile::Precompiles, primitives::{Env, ExecutionResult, Output, ResultAndState, TransactTo}, Database, EVMData, Inspector, @@ -206,6 +204,7 @@ impl JsInspector { )?) } + #[allow(unused)] fn try_fault(&mut self, step: StepLog, db: EvmDb) -> JsResult<()> { let step = step.into_js_object(&mut self.ctx)?; let db = db.into_js_object(&mut self.ctx)?; @@ -287,7 +286,11 @@ impl Inspector for JsInspector where DB: Database, { - fn step(&mut self, interp: &mut Interpreter, data: &mut EVMData<'_, DB>) -> InstructionResult { + fn step( + &mut self, + interp: &mut Interpreter<'_>, + data: &mut EVMData<'_, DB>, + ) -> InstructionResult { if self.step_fn.is_none() { return InstructionResult::Continue } @@ -297,7 +300,7 @@ where let step = StepLog { stack: StackObj(interp.stack.clone()), op: interp.current_opcode().into(), - memory: MemoryObj(interp.memory.clone()), + memory: MemoryObj(interp.shared_memory.clone()), pc: interp.program_counter() as u64, gas_remaining: interp.gas.remaining(), cost: interp.gas.spend(), @@ -324,32 +327,31 @@ where fn step_end( &mut self, - interp: &mut Interpreter, - data: &mut EVMData<'_, DB>, - eval: InstructionResult, + _interp: &mut Interpreter<'_>, + _data: &mut EVMData<'_, DB>, ) -> InstructionResult { if self.step_fn.is_none() { return InstructionResult::Continue } - if matches!(eval, return_revert!()) { - let db = EvmDb::new(data.journaled_state.state.clone(), self.to_db_service.clone()); - - let step = StepLog { - stack: StackObj(interp.stack.clone()), - op: interp.current_opcode().into(), - memory: MemoryObj(interp.memory.clone()), - pc: interp.program_counter() as u64, - gas_remaining: interp.gas.remaining(), - cost: interp.gas.spend(), - depth: data.journaled_state.depth(), - refund: interp.gas.refunded() as u64, - error: Some(format!("{:?}", eval)), - contract: self.active_call().contract.clone(), - }; - - let _ = self.try_fault(step, db); - } + // if matches!(eval, return_revert!()) { + // let db = EvmDb::new(data.journaled_state.state.clone(), self.to_db_service.clone()); + // + // let step = StepLog { + // stack: StackObj(interp.stack.clone()), + // op: interp.current_opcode().into(), + // memory: MemoryObj(interp.shared_memory.clone()), + // pc: interp.program_counter() as u64, + // gas_remaining: interp.gas.remaining(), + // cost: interp.gas.spend(), + // depth: data.journaled_state.depth(), + // refund: interp.gas.refunded() as u64, + // error: Some(format!("{:?}", eval)), + // contract: self.active_call().contract.clone(), + // }; + // + // let _ = self.try_fault(step, db); + // } InstructionResult::Continue } diff --git a/crates/revm/revm-inspectors/src/tracing/mod.rs b/crates/revm/revm-inspectors/src/tracing/mod.rs index 51c5a1e2d37e..7caa0c8d35f2 100644 --- a/crates/revm/revm-inspectors/src/tracing/mod.rs +++ b/crates/revm/revm-inspectors/src/tracing/mod.rs @@ -271,14 +271,17 @@ impl TracingInspector { /// /// This expects an existing [CallTrace], in other words, this panics if not within the context /// of a call. - fn start_step(&mut self, interp: &Interpreter, data: &EVMData<'_, DB>) { + fn start_step(&mut self, interp: &Interpreter<'_>, data: &EVMData<'_, DB>) { let trace_idx = self.last_trace_idx(); let trace = &mut self.traces.arena[trace_idx]; self.step_stack.push(StackStep { trace_idx, step_idx: trace.trace.steps.len() }); - let memory = - self.config.record_memory_snapshots.then(|| interp.memory.clone()).unwrap_or_default(); + let memory = self + .config + .record_memory_snapshots + .then(|| interp.shared_memory.clone()) + .unwrap_or_default(); let stack = self.config.record_stack_snapshots.then(|| interp.stack.clone()).unwrap_or_default(); @@ -300,7 +303,7 @@ impl TracingInspector { stack, push_stack: None, memory, - memory_size: interp.memory.len(), + memory_size: interp.shared_memory.len(), gas_remaining: self.gas_inspector.gas_remaining(), gas_refund_counter: interp.gas.refunded() as u64, @@ -316,9 +319,8 @@ impl TracingInspector { /// Invoked on [Inspector::step_end]. fn fill_step_on_step_end( &mut self, - interp: &Interpreter, + interp: &Interpreter<'_>, data: &EVMData<'_, DB>, - status: InstructionResult, ) { let StackStep { trace_idx, step_idx } = self.step_stack.pop().expect("can't fill step without starting a step first"); @@ -331,8 +333,8 @@ impl TracingInspector { if self.config.record_memory_snapshots { // resize memory so opcodes that allocated memory is correctly displayed - if interp.memory.len() > step.memory.len() { - step.memory.resize(interp.memory.len()); + if interp.shared_memory.len() > step.memory.len() { + step.memory.resize(interp.shared_memory.len()); } } if self.config.record_state_diff { @@ -371,7 +373,7 @@ impl TracingInspector { step.gas_cost = step.gas_remaining - self.gas_inspector.gas_remaining(); // set the status - step.status = status; + step.status = InstructionResult::Continue; } } @@ -381,13 +383,17 @@ where { fn initialize_interp( &mut self, - interp: &mut Interpreter, + interp: &mut Interpreter<'_>, data: &mut EVMData<'_, DB>, ) -> InstructionResult { self.gas_inspector.initialize_interp(interp, data) } - fn step(&mut self, interp: &mut Interpreter, data: &mut EVMData<'_, DB>) -> InstructionResult { + fn step( + &mut self, + interp: &mut Interpreter<'_>, + data: &mut EVMData<'_, DB>, + ) -> InstructionResult { if self.config.record_steps { self.gas_inspector.step(interp, data); self.start_step(interp, data); @@ -416,13 +422,12 @@ where fn step_end( &mut self, - interp: &mut Interpreter, + interp: &mut Interpreter<'_>, data: &mut EVMData<'_, DB>, - eval: InstructionResult, ) -> InstructionResult { if self.config.record_steps { - self.gas_inspector.step_end(interp, data, eval); - self.fill_step_on_step_end(interp, data, eval); + self.gas_inspector.step_end(interp, data); + self.fill_step_on_step_end(interp, data); } InstructionResult::Continue } diff --git a/crates/revm/revm-inspectors/src/tracing/opcount.rs b/crates/revm/revm-inspectors/src/tracing/opcount.rs index 623443579e4e..12d5e226ea0e 100644 --- a/crates/revm/revm-inspectors/src/tracing/opcount.rs +++ b/crates/revm/revm-inspectors/src/tracing/opcount.rs @@ -27,7 +27,7 @@ where { fn step( &mut self, - _interp: &mut Interpreter, + _interp: &mut Interpreter<'_>, _data: &mut EVMData<'_, DB>, ) -> InstructionResult { self.count += 1; diff --git a/crates/revm/revm-inspectors/src/tracing/types.rs b/crates/revm/revm-inspectors/src/tracing/types.rs index 8d2529029a27..925f00a623e1 100644 --- a/crates/revm/revm-inspectors/src/tracing/types.rs +++ b/crates/revm/revm-inspectors/src/tracing/types.rs @@ -13,7 +13,7 @@ use reth_rpc_types::trace::{ }, }; use revm::interpreter::{ - opcode, CallContext, CallScheme, CreateScheme, InstructionResult, Memory, OpCode, Stack, + opcode, CallContext, CallScheme, CreateScheme, InstructionResult, OpCode, SharedMemory, Stack, }; use serde::{Deserialize, Serialize}; use std::collections::{btree_map::Entry, BTreeMap, VecDeque}; @@ -641,7 +641,7 @@ pub(crate) struct CallTraceStep { /// All allocated memory in a step /// /// This will be empty if memory capture is disabled - pub(crate) memory: Memory, + pub(crate) memory: SharedMemory, /// Size of memory at the beginning of the step pub(crate) memory_size: usize, /// Remaining gas before step execution @@ -691,7 +691,7 @@ impl CallTraceStep { } if opts.is_memory_enabled() { - log.memory = Some(convert_memory(self.memory.data())); + log.memory = Some(convert_memory(self.memory.slice(0, self.memory.len()))); } log diff --git a/crates/revm/revm-inspectors/src/tracing/utils.rs b/crates/revm/revm-inspectors/src/tracing/utils.rs index 64468f825025..3d5224965809 100644 --- a/crates/revm/revm-inspectors/src/tracing/utils.rs +++ b/crates/revm/revm-inspectors/src/tracing/utils.rs @@ -1,9 +1,6 @@ //! Util functions for revm related ops -use reth_primitives::{ - contract::{create2_address_from_code, create_address}, - hex, Address, -}; +use reth_primitives::{hex, Address, B256}; use revm::{ interpreter::CreateInputs, primitives::{CreateScheme, SpecId}, @@ -32,9 +29,9 @@ pub(crate) fn gas_used(spec: SpecId, spent: u64, refunded: u64) -> u64 { #[inline] pub(crate) fn get_create_address(call: &CreateInputs, nonce: u64) -> Address { match call.scheme { - CreateScheme::Create => create_address(call.caller, nonce), + CreateScheme::Create => call.caller.create(nonce), CreateScheme::Create2 { salt } => { - create2_address_from_code(call.caller, call.init_code.clone(), salt) + call.caller.create2_from_code(B256::from(salt), call.init_code.clone()) } } } diff --git a/crates/revm/src/database.rs b/crates/revm/src/database.rs index 610ff79376f2..6712020b4306 100644 --- a/crates/revm/src/database.rs +++ b/crates/revm/src/database.rs @@ -72,7 +72,7 @@ impl Database for StateProviderDatabase { impl DatabaseRef for StateProviderDatabase { type Error = ::Error; - fn basic(&self, address: Address) -> Result, Self::Error> { + fn basic_ref(&self, address: Address) -> Result, Self::Error> { Ok(self.0.basic_account(address)?.map(|account| AccountInfo { balance: account.balance, nonce: account.nonce, @@ -81,7 +81,7 @@ impl DatabaseRef for StateProviderDatabase { })) } - fn code_by_hash(&self, code_hash: B256) -> Result { + fn code_by_hash_ref(&self, code_hash: B256) -> Result { let bytecode = self.0.bytecode_by_hash(code_hash)?; if let Some(bytecode) = bytecode { @@ -91,13 +91,13 @@ impl DatabaseRef for StateProviderDatabase { } } - fn storage(&self, address: Address, index: U256) -> Result { + fn storage_ref(&self, address: Address, index: U256) -> Result { let index = B256::new(index.to_be_bytes()); let ret = self.0.storage(address, index)?.unwrap_or_default(); Ok(ret) } - fn block_hash(&self, number: U256) -> Result { + fn block_hash_ref(&self, number: U256) -> Result { // Note: this unwrap is potentially unsafe Ok(self.0.block_hash(number.try_into().unwrap())?.unwrap_or_default()) } diff --git a/crates/rpc/rpc/src/debug.rs b/crates/rpc/rpc/src/debug.rs index f54510caff3b..3616a12c239d 100644 --- a/crates/rpc/rpc/src/debug.rs +++ b/crates/rpc/rpc/src/debug.rs @@ -604,7 +604,7 @@ where match req { JsDbRequest::Basic { address, resp } => { let acc = db - .basic(address) + .basic_ref(address) .map(|maybe_acc| { maybe_acc.map(|acc| Account { nonce: acc.nonce, @@ -617,13 +617,13 @@ where } JsDbRequest::Code { code_hash, resp } => { let code = db - .code_by_hash(code_hash) + .code_by_hash_ref(code_hash) .map(|code| code.bytecode) .map_err(|err| err.to_string()); let _ = resp.send(code); } JsDbRequest::StorageAt { address, index, resp } => { - let value = db.storage(address, index).map_err(|err| err.to_string()); + let value = db.storage_ref(address, index).map_err(|err| err.to_string()); let _ = resp.send(value); } } diff --git a/crates/rpc/rpc/src/eth/api/call.rs b/crates/rpc/rpc/src/eth/api/call.rs index 904eb5ab3f71..c94a67ec2e47 100644 --- a/crates/rpc/rpc/src/eth/api/call.rs +++ b/crates/rpc/rpc/src/eth/api/call.rs @@ -206,7 +206,7 @@ where if no_code_callee { // simple transfer, check if caller has sufficient funds let available_funds = - db.basic(env.tx.caller)?.map(|acc| acc.balance).unwrap_or_default(); + db.basic_ref(env.tx.caller)?.map(|acc| acc.balance).unwrap_or_default(); if env.tx.value > available_funds { return Err( RpcInvalidTransactionError::InsufficientFundsForTransfer.into() @@ -378,7 +378,7 @@ where let to = if let Some(to) = request.to { to } else { - let nonce = db.basic(from)?.unwrap_or_default().nonce; + let nonce = db.basic_ref(from)?.unwrap_or_default().nonce; from.create(nonce) }; diff --git a/crates/rpc/rpc/src/eth/api/transactions.rs b/crates/rpc/rpc/src/eth/api/transactions.rs index 815d716c9dd4..32e870318570 100644 --- a/crates/rpc/rpc/src/eth/api/transactions.rs +++ b/crates/rpc/rpc/src/eth/api/transactions.rs @@ -39,10 +39,7 @@ use revm::{ primitives::{BlockEnv, CfgEnv}, Inspector, }; -use revm_primitives::{ - db::DatabaseCommit, utilities::create_address, Env, ExecutionResult, ResultAndState, SpecId, - State, -}; +use revm_primitives::{db::DatabaseCommit, Env, ExecutionResult, ResultAndState, SpecId, State}; /// Helper alias type for the state's [CacheDB] pub(crate) type StateCacheDB<'r> = CacheDB>>; @@ -1058,7 +1055,7 @@ pub(crate) fn build_transaction_receipt_with_block_receipts( match tx.transaction.kind() { Create => { res_receipt.contract_address = - Some(create_address(transaction.signer(), tx.transaction.nonce())); + Some(transaction.signer().create(tx.transaction.nonce())); } Call(addr) => { res_receipt.to = Some(*addr); diff --git a/crates/rpc/rpc/src/eth/revm_utils.rs b/crates/rpc/rpc/src/eth/revm_utils.rs index 0281515b5326..a2a0634e1580 100644 --- a/crates/rpc/rpc/src/eth/revm_utils.rs +++ b/crates/rpc/rpc/src/eth/revm_utils.rs @@ -522,8 +522,8 @@ where EthApiError: From<::Error>, { // we need to fetch the account via the `DatabaseRef` to not update the state of the account, - // which is modified via `Database::basic` - let mut account_info = DatabaseRef::basic(db, account)?.unwrap_or_default(); + // which is modified via `Database::basic_ref` + let mut account_info = DatabaseRef::basic_ref(db, account)?.unwrap_or_default(); if let Some(nonce) = account_override.nonce { account_info.nonce = nonce.to();