refactor: error and transacted are states

Author: prestwich

src/evm.rs

@@ -873,14 +873,22 @@ impl<'a, Ext, Db: Database + DatabaseCommit, C: BlockContext<Ext, Db>> EvmNeedsT
     ) -> Result<EvmTransacted<'a, Ext, Db, C>, EvmErrored<'a, Ext, Db, C>> {
         self.fill_tx(filler).execute_tx()
     }
+
+    /// Execute a transaction, accept the output, and ignore errors.
+    pub fn run_tx<T: Tx>(self, filler: &T) -> Self {
+        match self.execute_tx(filler) {
+            Ok(evm) => evm.accept(),
+            Err(evm) => evm.discard_error(),
+        }
+    }
 }
 
 // --- READY
 
 impl<'a, Ext, Db: Database + DatabaseCommit, C: BlockContext<Ext, Db>> EvmReady<'a, Ext, Db, C> {
     /// Clear the current transaction environment.
     pub fn clear_tx(self) -> EvmNeedsTx<'a, Ext, Db, C> {
-        // NB: we do not clear the tx env here, as we read it during `BlockContext::apply_tx`
+        // NB: we do not clear the tx env here, as we may read it during `BlockContext::post_tx`
         EvmNeedsTx { inner: self.inner, state: NeedsTx(self.state.0) }
     }
 
@@ -899,6 +907,14 @@ impl<'a, Ext, Db: Database + DatabaseCommit, C: BlockContext<Ext, Db>> EvmReady<
             }
         }
     }
+
+    /// Execute the loaded transaction, accept the output, and ignore errors.
+    pub fn run(self) -> EvmNeedsTx<'a, Ext, Db, C> {
+        match self.execute_tx() {
+            Ok(evm) => evm.accept(),
+            Err(evm) => evm.discard_error(),
+        }
+    }
 }
 
 // --- ERRORED
@@ -928,6 +944,13 @@ impl<'a, Ext, Db: Database + DatabaseCommit, C: BlockContext<Ext, Db>, E>
     pub fn into_error(self) -> E {
         self.state.error
     }
+
+    /// Reset the EVM, returning the error and the EVM ready for the next
+    /// transaction.
+    pub fn take_error(self) -> (EvmNeedsTx<'a, Ext, Db, C>, E) {
+        let Trevm { inner, state: ErroredState { context, error } } = self;
+        (Trevm { inner, state: NeedsTx(context) }, error)
+    }
 }
 
 impl<'a, Ext, Db: Database + DatabaseCommit, C: BlockContext<Ext, Db>>
@@ -1063,7 +1086,7 @@ impl<'a, Ext, Db: Database + DatabaseCommit, C: BlockContext<Ext, Db>>
     }
 
     /// Accept the state changes, skipping the [`BlockContext::after_tx`]
-    /// method, and applying them directly to the database.
+    /// method, and committing them directly to the database.
     ///
     /// This is a low-level API, and is not intended for general use. It is
     /// almost always better to use [`Self::accept`] instead.

src/lib.rs

@@ -48,7 +48,7 @@
 //!
 //! ```
 //! use revm::{EvmBuilder, db::InMemoryDB};
-//! use trevm::{TrevmBuilder, TransactedError, Cfg, Block, Tx, };
+//! use trevm::{TrevmBuilder, EvmErrored, Cfg, Block, Tx, };
 //!
 //! # fn t<C: Cfg, B: Block, T: Tx>(cfg: &C, block: &B, tx: &T)
 //! # -> Result<(), Box<dyn std::error::Error>> {
@@ -57,7 +57,7 @@
 //!     .build_trevm()
 //!     .fill_cfg(cfg)
 //!     .fill_block(block)
-//!     .apply_tx(tx);
+//!     .execute_tx(tx);
 //! # Ok(())
 //! # }
 //!
@@ -107,9 +107,9 @@
 //! ```
 //! # use revm::{EvmBuilder, db::{InMemoryDB, BundleState}, State,
 //! # StateBuilder};
-//! # use trevm::{TrevmBuilder, TransactedError, Cfg, Block, Tx, BlockOutput,
+//! # use trevm::{TrevmBuilder, EvmErrored, Cfg, Block, Tx, BlockOutput,
 //! # EvmNeedsCfg, EvmNeedsFirstBlock, EvmNeedsTx, EvmReady, EvmNeedsNextBlock,
-//! # EvmBlockComplete, Shanghai};
+//! # EvmBlockComplete, Shanghai, EvmTransacted};
 //! # fn t<C: Cfg, B: Block, T: Tx>(cfg: &C, block: &B, tx: &T)
 //! # -> Result<(), Box<dyn std::error::Error>> {
 //! let state = StateBuilder::new_with_database(InMemoryDB::default()).build();
@@ -128,21 +128,18 @@
 //! let trevm: EvmNeedsTx<'_, _, _, _> = trevm.open_block(
 //!     block,
 //!     Shanghai::default()
-//! ).map_err(TransactedError::into_error)?;
+//! ).map_err(EvmErrored::into_error)?;
 //! // Filling the tx gets us to `EvmReady`.
 //! let trevm: EvmReady<'_, _, _, _> = trevm.fill_tx(tx);
 //!
 //! // Applying the tx or ignoring the error gets us back to `EvmNeedsTx``.
-//! let trevm: EvmNeedsTx<'_, _, _, _> = match trevm.execute_tx() {
-//!     Ok(transacted) => transacted.apply(),
-//!     Err(e) => e.discard_error(),
-//! };
+//! let trevm: EvmNeedsTx<'_, _, _, _> = trevm.run();
 //!
 //! // Clearing or closing a block gets us to `EvmNeedsNextBlock`, ready for the
 //! // next block.
 //! let trevm: EvmBlockComplete<'_, _, _, _> = trevm
 //!     .close_block()
-//!     .map_err(TransactedError::into_error)?;;
+//!     .map_err(EvmErrored::into_error)?;;
 //!
 //! // During block execution, a context object
 //! let (context, trevm): (Shanghai<'_>, EvmNeedsNextBlock<'_, _, _>) = trevm
@@ -195,7 +192,7 @@
 //!
 //! ```
 //! # use revm::{EvmBuilder, db::InMemoryDB};
-//! # use trevm::{TrevmBuilder, TransactedError, Cfg, Block, Tx,
+//! # use trevm::{TrevmBuilder, EvmErrored, Cfg, Block, Tx,
 //! # Shanghai, Cancun};
 //! # use alloy_primitives::B256;
 //! # fn t<C: Cfg, B: Block, T: Tx>(cfg: &C, block: &B, tx: &T)
@@ -213,12 +210,13 @@
 //!     // The pre-block logic is applied here
 //!     .open_block(block, context)
 //!     // Note that the logic is fallible, so we have to handle errors
-//!     .map_err(TransactedError::into_error)?
-//!     .apply_tx(tx)
-//!     .map_err(TransactedError::into_error)?
+//!     .map_err(EvmErrored::into_error)?
+//!     .execute_tx(tx)
+//!     .map_err(EvmErrored::into_error)?
+//!     .accept()
 //!     // Closing the block applies the post-block logic, and is also fallible
 //!     .close_block()
-//!     .map_err(TransactedError::into_error)?
+//!     .map_err(EvmErrored::into_error)?
 //!     // This splits the context, and puts trevm into `EvmNeedsNextBlock`
 //!     .take_context();
 //! # Ok(())
@@ -238,7 +236,7 @@
 //!
 //! ```
 //! # use revm::{EvmBuilder, db::InMemoryDB};
-//! # use trevm::{TrevmBuilder, TransactedError, Cfg, Block, Tx,
+//! # use trevm::{TrevmBuilder, EvmErrored, Cfg, Block, Tx,
 //! # Shanghai, Cancun};
 //! # use alloy_primitives::B256;
 //! # fn t<C: Cfg, B: Block, T: Tx>(cfg: &C, block: &B, tx: &T)
@@ -259,7 +257,7 @@
 //!         trevm
 //!     }
 //!     Err(transacted_error) => {
-//!         let (trevm, error) = transacted_error.into_parts();
+//!         let (trevm, error) = transacted_error.take_error();
 //!         // Handle the error here, and return the EVM if you want
 //!         // to keep going
 //!         trevm
@@ -360,12 +358,12 @@
 //!  +------+   +----------+                                 |
 //!  |Finish}   |EvmNeedsTx| <------ open_block() -----------+
 //!  +------+   +----------+
-//!              ^       |                                +--------+
-//!              |       +------- fill_tx() ------------> |EvmReady|
-//!              |                                        +--------+
-//!              |             +----------+                   |
-//!              +- apply() ---|Transacted| <-- execute_tx() -+
-//!              or discard()  +----------+
+//!              ^       |                                   +--------+
+//!              |       +------- fill_tx() ---------------> |EvmReady|
+//!              |                                           +--------+
+//!              |             +-------------+                    |
+//!              +- apply() ---|EvmTransacted| <-- execute_tx() --+
+//!              or discard()  +-------------+
 //! ```
 //!
 //! A basic block loop should look like this:
@@ -377,10 +375,7 @@
 //!
 //! for tx in txs {
 //!     // apply the transaction, discard the error if any
-//!     evm = match evm.apply_tx(tx) {
-//!         Ok(evm) => evm,
-//!         Err(e) => { e.discard_error() }
-//!     }
+//!     evm = match evm.run_tx(tx);
 //! }
 //!
 //! // close out the EVM, getting the final state

src/lifecycle/trait.rs

@@ -56,7 +56,8 @@ pub trait BlockContext<Ext, Db: Database + DatabaseCommit> {
     /// state. This will be called by [`Trevm`] for each transaction in a block.
     ///
     /// This is the hook to produce receipts, update cumulative gas used,
-    /// inspect logs, etc etc.
+    /// inspect logs, etc etc. You can read transaction details from `evm.tx()`
+    /// and the result of the transaction from `result`.
     ///
     /// Generally this should end by calling `evm.db_mut().commit(result.state)`
     /// however, it is allowed to discard the transaction instead of committing