Struct ConcurrentState 

pub struct ConcurrentState<Db> {
    pub info: ConcurrentStateInfo,
    /* private fields */
}

Available on crate feature concurrent-db only.

State of the blockchain.

A version of revm::database::State that can be shared between threads.

Fields

info: ConcurrentStateInfo

Non-DB state cache and transition information.

Implementations

impl<Db> ConcurrentState<Db>

pub fn into_parts(self) -> (Db, ConcurrentStateInfo)

Deconstruct the ConcurrentState into its parts.

pub fn bundle_size_hint(&self) -> usize

Returns the size hint for the inner bundle state. See BundleState::size_hint for more info.

pub const fn set_state_clear_flag(&mut self, has_state_clear: bool)

State clear EIP-161 is enabled in Spurious Dragon hardfork.

pub fn insert_not_existing(&mut self, address: Address)

Insert not existing account into cache state.

pub fn insert_account(&mut self, address: Address, info: AccountInfo)

Insert account into cache state.

pub fn insert_account_with_storage( &mut self, address: Address, info: AccountInfo, storage: PlainStorage, )

Insert account with storage into cache state.

pub fn apply_transition( &mut self, transitions: Vec<(Address, TransitionAccount)>, )

Apply evm transitions to transition state.

pub fn merge_transitions(&mut self, retention: BundleRetention)

Take all transitions and merge them inside bundle state. This action will create final post state and all reverts so that we at any time revert state of bundle to the state before transition is applied.

pub fn take_bundle(&mut self) -> BundleState

Takes the BundleState changeset from the ConcurrentState, replacing it with an empty one.

This will not apply any pending TransitionState. It is recommended to call ConcurrentState::merge_transitions before taking the bundle.

If the State has been built with the revm::database::StateBuilder::with_bundle_prestate option, the pre-state will be taken along with any changes made by ConcurrentState::merge_transitions.

impl<Db: DatabaseRef + Sync> ConcurrentState<Db>

pub const fn new(database: Db, info: ConcurrentStateInfo) -> Self

Create a new ConcurrentState with the given database and cache state.

pub fn increment_balances( &mut self, balances: impl IntoIterator<Item = (Address, u128)>, ) -> Result<(), Db::Error>

Iterate over received balances and increment all account balances. If account is not found inside cache state it will be loaded from database.

Update will create transitions for all accounts that are updated.

Like CacheAccount::increment_balance, this assumes that incremented balances are not zero, and will not overflow once incremented. If using this to implement withdrawals, zero balances must be filtered out before calling this function.

pub fn drain_balances( &mut self, addresses: impl IntoIterator<Item = Address>, ) -> Result<Vec<u128>, Db::Error>

Drain balances from given account and return those values.

It is used for DAO hardfork state change to move values from given accounts.

pub fn load_cache_account_mut( &self, address: Address, ) -> Result<RefMut<'_, Address, CacheAccount>, Db::Error>

Get a mutable reference to the CacheAccount for the given address. If the account is not found in the cache, it will be loaded from the database and inserted into the cache.

This function locks that account in the cache while the reference is held. For that timeframe, it will block other tasks attempting to access that account. As a result, this function should be used sparingly.

pub fn child(self: &Arc<Self>) -> Child<Db>

where Db: Send,

Create a Child DB that wraps this state in another cache layer.

This allows the ConcurrentState to be shared between threads, with each thread having a separate cache for its local changes. The child can later be merged back into the parent with Self::merge_child IF no other children or copies of the Arc<Self> exist.

pub fn merge_child( self: &mut Arc<Self>, child: Child<Db>, ) -> Result<(), ConcurrentStateError>

Merge a child DB into this DB, incorporating its changes and overwriting any present values.

This function needs to take ownership of the Child, as the child copntains an Arc of the parent. This Arc must be dropped to ensure that the parent’s pointer is unique, allowing the parent to be modified via Arc::get_mut.

If other children or other copies of the Arc<Self> exist, this will fail with a ConcurrentStateError. error. If the child belongs to another parent, this will also fail.

These conditions can be checked via Self::can_merge, please see that function’s documentation for a possible race condition.

pub fn can_merge( self: &Arc<Self>, child: &Child<Db>, ) -> Result<(), ConcurrentStateError>

True if the child can be merged into this state, false otherwise.

Note

Race conditions can occur if the child is shared between threads, as the child may be cloned AFTER this check is made, but BEFORE the child is merged. In this case the function will spuriously return Ok(()) even though the merge will fail. To avoid this, ensure that the child is not shared between threads when Self::can_merge is called.

pub fn is_parent(self: &Arc<Self>, child: &Child<Db>) -> bool

True if the child is a child of this state, false otherwise.

Trait Implementations

impl<Db: DatabaseRef + Sync> Database for ConcurrentState<Db>

type Error = <ConcurrentState<Db> as DatabaseRef>::Error

The database error type.

fn basic( &mut self, address: Address, ) -> Result<Option<AccountInfo>, Self::Error>

Gets basic account information.

fn code_by_hash(&mut self, code_hash: B256) -> Result<Bytecode, Self::Error>

Gets account code by its hash.

fn storage( &mut self, address: Address, index: U256, ) -> Result<U256, Self::Error>

Gets storage value of address at index.

fn block_hash(&mut self, number: u64) -> Result<B256, Self::Error>

Gets block hash by block number.

fn storage_by_account_id( &mut self, address: Address, account_id: usize, storage_key: Uint<256, 4>, ) -> Result<Uint<256, 4>, Self::Error>

Gets storage value of account by its id. By default call Database::storage method.

impl<Db: DatabaseRef + Sync> DatabaseCommit for ConcurrentState<Db>

fn commit(&mut self, evm_state: HashMap<Address, Account>)

Commit changes to the database.

fn commit_iter(&mut self, changes: &mut dyn Iterator<Item = (Address, Account)>)

Commit changes to the database with an iterator.

impl<Db: DatabaseRef + Sync> DatabaseRef for ConcurrentState<Db>

type Error = <Db as DatabaseRef>::Error

The database error type.

fn basic_ref( &self, address: Address, ) -> Result<Option<AccountInfo>, Self::Error>

Gets basic account information.

fn code_by_hash_ref(&self, code_hash: B256) -> Result<Bytecode, Self::Error>

Gets account code by its hash.

fn storage_ref( &self, address: Address, index: U256, ) -> Result<U256, Self::Error>

Gets storage value of address at index.

fn block_hash_ref(&self, number: u64) -> Result<B256, Self::Error>

Gets block hash by block number.

fn storage_by_account_id_ref( &self, address: Address, account_id: usize, storage_key: Uint<256, 4>, ) -> Result<Uint<256, 4>, Self::Error>

Gets storage value of account by its id.

impl<Db: Debug> Debug for ConcurrentState<Db>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Db> From<State<Db>> for ConcurrentState<Db>

where Db: DatabaseRef,

fn from(value: State<Db>) -> Self

Converts to this type from the input type.

impl<Db: DatabaseRef + Sync> StateAcc for ConcurrentState<Db>

fn set_state_clear_flag(&mut self, flag: bool)

Set the state clear flag. See State::set_state_clear_flag.

fn merge_transitions(&mut self, retention: BundleRetention)

Merge transitions into the bundle. See State::merge_transitions.

fn take_bundle(&mut self) -> BundleState

Take the bundle. See State::take_bundle.

fn set_block_hashes(&mut self, block_hashes: &BTreeMap<u64, B256>)

Set the block hashes, overriding any existing values, and inserting any absent values.