feat(deps): bump revm

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "trevm"
-version = "0.23.8"
+version = "0.27.0"
 rust-version = "1.83.0"
 edition = "2021"
 authors = ["init4"]
@@ -34,7 +34,7 @@ name = "fork_ref_transact"
 required-features = ["alloy-db"]
 
 [dependencies]
-alloy = { version = "1.0.5", default-features = false, features = [
+alloy = { version = "1.0.13", default-features = false, features = [
     "consensus",
     "rpc-types-mev",
     "eips",
@@ -44,7 +44,7 @@ alloy = { version = "1.0.5", default-features = false, features = [
     "sol-types",
 ] }
 
-revm = { version = "23.1.0", default-features = false }
+revm = { version = "27.0.1", default-features = false }
 
 dashmap = { version = "6.1.0", optional = true }
 tracing = { version = "0.1.41", optional = true }
@@ -53,10 +53,10 @@ thiserror = "2.0.11"
 tokio = { version = "1.44", optional = true }
 
 [dev-dependencies]
-revm = { version = "23.1.0", features = ["serde-json", "std", "alloydb"] }
+revm = { version = "27.0.1", features = ["serde-json", "std", "alloydb"] }
 trevm = { path = ".", features = ["test-utils"] }
 
-alloy = { version = "1.0.5", features = ["providers", "transports"] }
+alloy = { version = "1.0.13", features = ["providers", "transports"] }
 
 # misc
 eyre = "0.6"
@@ -87,7 +87,6 @@ estimate_gas = ["optional_eip3607", "optional_no_base_fee", "dep:tracing"]
 test-utils = ["revm/std", "revm/serde-json", "revm/alloydb"]
 
 secp256k1 = ["revm/secp256k1"]
-secp256r1 = ["revm/secp256r1"]
 c-kzg = ["revm/c-kzg"]
 blst = ["revm/blst"]
 

src/driver/alloy.rs

@@ -57,11 +57,11 @@ impl<Db: Database> core::fmt::Display for BundleError<Db> {
             Self::BundleEmpty => write!(f, "bundle has no transactions"),
             Self::Eip4844BlobGasExceeded => write!(f, "max blob gas limit exceeded"),
             Self::UnsupportedTransactionType => write!(f, "unsupported transaction type"),
-            Self::TransactionDecodingError(err) => write!(f, "transaction decoding error: {}", err),
+            Self::TransactionDecodingError(err) => write!(f, "transaction decoding error: {err}"),
             Self::TransactionSenderRecoveryError(err) => {
-                write!(f, "transaction sender recovery error: {}", err)
+                write!(f, "transaction sender recovery error: {err}")
             }
-            Self::EVMError { inner } => write!(f, "internal EVM error: {}", inner),
+            Self::EVMError { inner } => write!(f, "internal EVM error: {inner}"),
         }
     }
 }
@@ -107,11 +107,11 @@ impl<Db: Database> core::fmt::Debug for BundleError<Db> {
             Self::BlockNumberMismatch => write!(f, "BlockNumberMismatch"),
             Self::BundleEmpty => write!(f, "BundleEmpty"),
             Self::BundleReverted => write!(f, "BundleReverted"),
-            Self::TransactionDecodingError(e) => write!(f, "TransactionDecodingError({:?})", e),
+            Self::TransactionDecodingError(e) => write!(f, "TransactionDecodingError({e:?})"),
             Self::UnsupportedTransactionType => write!(f, "UnsupportedTransactionType"),
             Self::Eip4844BlobGasExceeded => write!(f, "Eip4844BlobGasExceeded"),
             Self::TransactionSenderRecoveryError(e) => {
-                write!(f, "TransactionSenderRecoveryError({:?})", e)
+                write!(f, "TransactionSenderRecoveryError({e:?})")
             }
             Self::EVMError { .. } => write!(f, "EVMError"),
         }
@@ -278,7 +278,7 @@ where
     ) -> DriveBundleResult<Self, Db, Insp> {
         // Check if the block we're in is valid for this bundle. Both must match
         trevm_ensure!(
-            trevm.inner().block.number == self.bundle.block_number,
+            trevm.inner().block.number == U256::from(self.bundle.block_number),
             trevm,
             BundleError::BlockNumberMismatch
         );
@@ -296,7 +296,7 @@ where
 
         // Set the state block number this simulation was based on
         self.response.state_block_number =
-            self.bundle.state_block_number.as_number().unwrap_or(trevm.inner().block.number);
+            self.bundle.state_block_number.as_number().unwrap_or(trevm.block_number().to());
 
         let bundle_filler = BundleBlockFiller::from(&self.bundle);
 
@@ -416,15 +416,15 @@ where
         {
             // Check if the block we're in is valid for this bundle. Both must match
             trevm_ensure!(
-                trevm.inner().block.number == self.bundle.block_number,
+                trevm.block_number() == U256::from(self.bundle.block_number),
                 trevm,
                 BundleError::BlockNumberMismatch
             );
 
             // Check for start timestamp range validity
             if let Some(min_timestamp) = self.bundle.min_timestamp {
                 trevm_ensure!(
-                    trevm.inner().block.timestamp >= min_timestamp,
+                    trevm.block_timestamp() >= U256::from(min_timestamp),
                     trevm,
                     BundleError::TimestampOutOfRange
                 );
@@ -433,7 +433,7 @@ where
             // Check for end timestamp range validity
             if let Some(max_timestamp) = self.bundle.max_timestamp {
                 trevm_ensure!(
-                    trevm.inner().block.timestamp <= max_timestamp,
+                    trevm.block_timestamp() <= U256::from(max_timestamp),
                     trevm,
                     BundleError::TimestampOutOfRange
                 );
@@ -503,9 +503,9 @@ struct BundleBlockFiller {
 impl Block for BundleBlockFiller {
     fn fill_block_env(&self, block_env: &mut revm::context::block::BlockEnv) {
         if let Some(timestamp) = self.timestamp {
-            block_env.timestamp = timestamp;
+            block_env.timestamp = U256::from(timestamp);
         } else {
-            block_env.timestamp += 12;
+            block_env.timestamp += U256::from(12);
         }
         if let Some(gas_limit) = self.gas_limit {
             block_env.gas_limit = gas_limit;
@@ -517,7 +517,7 @@ impl Block for BundleBlockFiller {
             block_env.basefee = base_fee.try_into().unwrap_or(u64::MAX);
         }
         if let Some(block_number) = self.block_number.as_number() {
-            block_env.number = block_number;
+            block_env.number = U256::from(block_number);
         }
     }
 }
@@ -559,7 +559,7 @@ where
     ) -> DriveBundleResult<Self, Db, Insp> {
         // Check if the block we're in is valid for this bundle. Both must match
         trevm_ensure!(
-            trevm.inner().block.number == self.block_number,
+            trevm.block_number() == U256::from(self.block_number),
             trevm,
             BundleError::BlockNumberMismatch
         );
@@ -650,7 +650,7 @@ where
     ) -> DriveBundleResult<Self, Db, Insp> {
         // Check if the block we're in is valid for this bundle. Both must match
         trevm_ensure!(
-            trevm.inner().block.number == self.block_number,
+            trevm.block_number() == U256::from(self.block_number),
             trevm,
             BundleError::BlockNumberMismatch
         );
@@ -659,7 +659,7 @@ where
 
         if let Some(min_timestamp) = self.min_timestamp {
             trevm_ensure!(
-                trevm.inner().block.timestamp >= min_timestamp,
+                trevm.block_timestamp() >= U256::from(min_timestamp),
                 trevm,
                 BundleError::TimestampOutOfRange
             );
@@ -668,7 +668,7 @@ where
         // Check for end timestamp range validity
         if let Some(max_timestamp) = self.max_timestamp {
             trevm_ensure!(
-                trevm.inner().block.timestamp <= max_timestamp,
+                trevm.block_timestamp() <= U256::from(max_timestamp),
                 trevm,
                 BundleError::TimestampOutOfRange
             );

src/evm.rs

@@ -275,7 +275,7 @@ where
         &mut self,
         address: Address,
     ) -> Result<Option<AccountInfo>, <Db as Database>::Error> {
-        self.inner.db().basic(address)
+        self.inner.db_mut().basic(address)
     }
 
     /// Get the current nonce for a specific address
@@ -300,7 +300,7 @@ where
         address: Address,
         slot: U256,
     ) -> Result<U256, <Db as Database>::Error> {
-        self.inner.db().storage(address, slot)
+        self.inner.db_mut().storage(address, slot)
     }
 
     /// Get the code at the given account, if any.
@@ -312,7 +312,7 @@ where
     ) -> Result<Option<Bytecode>, <Db as Database>::Error> {
         let acct_info = self.try_read_account(address)?;
         match acct_info {
-            Some(acct) => Ok(Some(self.inner.db().code_by_hash(acct.code_hash)?)),
+            Some(acct) => Ok(Some(self.inner.db_mut().code_by_hash(acct.code_hash)?)),
             None => Ok(None),
         }
     }
@@ -409,7 +409,7 @@ where
     ///
     /// Note: due to revm's DB model, this requires a mutable pointer.
     pub fn read_account(&mut self, address: Address) -> Option<AccountInfo> {
-        self.inner.db().basic(address).expect("infallible")
+        self.inner.db_mut().basic(address).expect("infallible")
     }
 
     /// Get the current nonce for a specific address
@@ -430,15 +430,15 @@ where
     ///
     /// Note: due to revm's DB model, this requires a mutable pointer.
     pub fn read_storage(&mut self, address: Address, slot: U256) -> U256 {
-        self.inner.db().storage(address, slot).expect("infallible")
+        self.inner.db_mut().storage(address, slot).expect("infallible")
     }
 
     /// Get the code at the given account, if any.
     ///
     /// Note: due to revm's DB model, this requires a mutable pointer.
     pub fn read_code(&mut self, address: Address) -> Option<Bytecode> {
         let acct_info = self.read_account(address)?;
-        Some(self.inner.db().code_by_hash(acct_info.code_hash).expect("infallible"))
+        Some(self.inner.db_mut().code_by_hash(acct_info.code_hash).expect("infallible"))
     }
 }
 
@@ -493,7 +493,7 @@ where
     where
         Db: DatabaseCommit,
     {
-        self.inner.db().commit(state);
+        self.inner.db_mut().commit(state);
     }
 
     /// Modify an account with a closure and commit the modified account. This
@@ -735,7 +735,7 @@ where
     /// Set the [EIP-161] state clear flag, activated in the Spurious Dragon
     /// hardfork.
     pub fn set_state_clear_flag(&mut self, flag: bool) {
-        self.inner.db().set_state_clear_flag(flag)
+        self.inner.db_mut().set_state_clear_flag(flag)
     }
 }
 
@@ -753,7 +753,7 @@ where
         &mut self,
         flag: bool,
     ) -> Result<(), <Db as TryStateAcc>::Error> {
-        self.inner.db().try_set_state_clear_flag(flag)
+        self.inner.db_mut().try_set_state_clear_flag(flag)
     }
 }
 
@@ -1129,12 +1129,12 @@ where
     }
 
     /// Get the current block number.
-    pub fn block_number(&self) -> u64 {
+    pub fn block_number(&self) -> U256 {
         self.block().number()
     }
 
     /// Get the current block timestamp.
-    pub fn block_timestamp(&self) -> u64 {
+    pub fn block_timestamp(&self) -> U256 {
         self.block().timestamp()
     }
 
@@ -1204,8 +1204,8 @@ where
     /// [`State::take_bundle`]: revm::database::State::take_bundle
     pub fn finish(self) -> BundleState {
         let Self { inner: mut evm, .. } = self;
-        evm.db().merge_transitions(BundleRetention::Reverts);
-        let bundle = evm.db().take_bundle();
+        evm.db_mut().merge_transitions(BundleRetention::Reverts);
+        let bundle = evm.db_mut().take_bundle();
 
         bundle
     }
@@ -1231,7 +1231,7 @@ where
     pub fn try_finish(
         mut self,
     ) -> Result<BundleState, EvmErrored<Db, Insp, <Db as TryStateAcc>::Error>> {
-        let db = self.inner.db();
+        let db = self.inner.db_mut();
 
         trevm_try!(db.try_merge_transitions(BundleRetention::Reverts), self);
 
@@ -1544,7 +1544,7 @@ where
         overrides.fill_block(&mut self.inner);
 
         if let Some(hashes) = overrides.block_hash.as_ref() {
-            self.inner.db().set_block_hashes(hashes)
+            self.inner.db_mut().set_block_hashes(hashes)
         }
 
         self
@@ -1590,7 +1590,7 @@ where
         overrides.fill_block(&mut self.inner);
 
         if let Some(hashes) = overrides.block_hash.as_ref() {
-            trevm_try!(self.inner.db().try_set_block_hashes(hashes), self);
+            trevm_try!(self.inner.db_mut().try_set_block_hashes(hashes), self);
         }
 
         Ok(self)
@@ -1636,10 +1636,10 @@ where
     }
 
     /// Execute the loaded transaction. This is a wrapper around
-    /// [`InspectEvm::inspect_replay`] and produces either [`EvmTransacted`] or
+    /// [`InspectEvm::inspect_tx`] and produces either [`EvmTransacted`] or
     /// [`EvmErrored`].
     pub fn run(mut self) -> Result<EvmTransacted<Db, Insp>, EvmErrored<Db, Insp>> {
-        let result = self.inner.inspect_replay();
+        let result = self.inner.inspect_tx(self.tx().clone());
 
         let Self { inner, .. } = self;
 
@@ -2110,7 +2110,7 @@ where
     {
         let Self { mut inner, state: TransactedState { result } } = self;
 
-        inner.db().commit(result.state);
+        inner.db_mut().commit(result.state);
 
         (result.result, Trevm { inner, state: NeedsTx::new() })
     }
@@ -2133,7 +2133,7 @@ where
     {
         let Self { mut inner, state: TransactedState { result } } = self;
 
-        trevm_try!(inner.db().try_commit(result.state), Trevm { inner, state: NeedsTx::new() });
+        trevm_try!(inner.db_mut().try_commit(result.state), Trevm { inner, state: NeedsTx::new() });
         Ok((result.result, Trevm { inner, state: NeedsTx::new() }))
     }
 

src/ext.rs

@@ -83,7 +83,7 @@ pub trait EvmExtUnchecked<Db: Database> {
         let mut acct = self.account(address)?;
         let old = self.storage(address, index)?;
 
-        let change = EvmStorageSlot::new_changed(old, value);
+        let change = EvmStorageSlot::new_changed(old, value, 0);
         acct.storage.insert(index, change);
         acct.mark_touch();
 
@@ -171,11 +171,11 @@ pub trait EvmExtUnchecked<Db: Database> {
     }
 }
 
-impl<Ctx, Insp, Inst, Prec> EvmExtUnchecked<Ctx::Db> for Evm<Ctx, Insp, Inst, Prec>
+impl<Ctx, Insp, Inst, Prec, Frame> EvmExtUnchecked<Ctx::Db> for Evm<Ctx, Insp, Inst, Prec, Frame>
 where
     Ctx: ContextTr,
 {
     fn db_mut_ext(&mut self) -> &mut Ctx::Db {
-        self.ctx.db()
+        self.ctx.db_mut()
     }
 }