feat: add additional internals fns (alloy-rs#214)

* feat: add additional internals fns

* fmt

Author: mattsse

crates/evm/src/traits.rs

@@ -5,7 +5,7 @@ use alloc::boxed::Box;
 use alloy_primitives::{Address, Log, B256, U256};
 use core::{error::Error, fmt, fmt::Debug};
 use revm::{
-    context::{Block, DBErrorMarker, JournalTr},
+    context::{journaled_state::TransferError, Block, DBErrorMarker, JournalTr},
     interpreter::{SStoreResult, StateLoad},
     primitives::{StorageKey, StorageValue},
     state::{Account, AccountInfo, Bytecode},
@@ -52,6 +52,24 @@ trait EvmInternalsTr: Database<Error = ErasedError> + Debug {
         address: Address,
     ) -> Result<StateLoad<&Account>, EvmInternalsError>;
 
+    /// Increments the balance of the account.
+    fn balance_incr(&mut self, address: Address, balance: U256) -> Result<(), EvmInternalsError>;
+
+    /// Transfers the balance from one account to another.
+    ///
+    /// This will load both accounts
+    fn transfer(
+        &mut self,
+        from: Address,
+        to: Address,
+        balance: U256,
+    ) -> Result<Option<TransferError>, EvmInternalsError>;
+
+    /// Increments the nonce of the account.
+    ///
+    /// This creates a new journal entry with this change.
+    fn nonce_bump_journal_entry(&mut self, address: Address);
+
     fn sload(
         &mut self,
         address: Address,
@@ -62,6 +80,9 @@ trait EvmInternalsTr: Database<Error = ErasedError> + Debug {
 
     fn set_code(&mut self, address: Address, code: Bytecode);
 
+    /// Sets bytecode with hash. Assume that account is warm.
+    fn set_code_with_hash(&mut self, address: Address, code: Bytecode, hash: B256);
+
     fn sstore(
         &mut self,
         address: Address,
@@ -118,6 +139,23 @@ where
         self.0.load_account_with_code(address).map_err(EvmInternalsError::database)
     }
 
+    fn balance_incr(&mut self, address: Address, balance: U256) -> Result<(), EvmInternalsError> {
+        self.0.balance_incr(address, balance).map_err(EvmInternalsError::database)
+    }
+
+    fn transfer(
+        &mut self,
+        from: Address,
+        to: Address,
+        balance: U256,
+    ) -> Result<Option<TransferError>, EvmInternalsError> {
+        self.0.transfer(from, to, balance).map_err(EvmInternalsError::database)
+    }
+
+    fn nonce_bump_journal_entry(&mut self, address: Address) {
+        self.0.nonce_bump_journal_entry(address);
+    }
+
     fn sload(
         &mut self,
         address: Address,
@@ -134,6 +172,10 @@ where
         self.0.set_code(address, code);
     }
 
+    fn set_code_with_hash(&mut self, address: Address, code: Bytecode, hash: B256) {
+        self.0.set_code_with_hash(address, code, hash);
+    }
+
     fn sstore(
         &mut self,
         address: Address,
@@ -202,6 +244,34 @@ impl<'a> EvmInternals<'a> {
         self.internals.load_account_code(address)
     }
 
+    /// Increments the balance of the account.
+    pub fn balance_incr(
+        &mut self,
+        address: Address,
+        balance: U256,
+    ) -> Result<(), EvmInternalsError> {
+        self.internals.balance_incr(address, balance)
+    }
+
+    /// Transfers the balance from one account to another.
+    ///
+    /// This will load both accounts and return an error if the transfer fails.
+    pub fn transfer(
+        &mut self,
+        from: Address,
+        to: Address,
+        balance: U256,
+    ) -> Result<Option<TransferError>, EvmInternalsError> {
+        self.internals.transfer(from, to, balance)
+    }
+
+    /// Increments the nonce of the account.
+    ///
+    /// This creates a new journal entry with this change.
+    pub fn nonce_bump_journal_entry(&mut self, address: Address) {
+        self.internals.nonce_bump_journal_entry(address);
+    }
+
     /// Loads a storage slot.
     pub fn sload(
         &mut self,
@@ -221,6 +291,13 @@ impl<'a> EvmInternals<'a> {
         self.internals.set_code(address, code);
     }
 
+    /// Sets bytecode with hash to the account.
+    ///
+    /// Assumes that the account is warm.
+    pub fn set_code_with_hash(&mut self, address: Address, code: Bytecode, hash: B256) {
+        self.internals.set_code_with_hash(address, code, hash);
+    }
+
     /// Stores the storage value in Journal state.
     pub fn sstore(
         &mut self,