Struct reth_revm::db::states::bundle_state::BundleState

pub struct BundleState {
    pub state: HashMap<Address, BundleAccount>,
    pub contracts: HashMap<FixedBytes<32>, Bytecode>,
    pub reverts: Reverts,
    pub state_size: usize,
    pub reverts_size: usize,
}

Bundle state contain only values that got changed

For every account it contains both original and present state. This is needed to decide if there were any changes to the account.

Reverts and created when TransitionState is applied to BundleState. And can be used to revert BundleState to the state before transition.

Fields

state: HashMap<Address, BundleAccount>

Account state.

contracts: HashMap<FixedBytes<32>, Bytecode>

All created contracts in this block.

reverts: Reverts

Changes to revert.

Note: Inside vector is not sorted by address. But it is unique by address.

state_size: usize

The size of the plain state in the bundle state.

reverts_size: usize

The size of reverts in the bundle state.

Implementations

impl BundleState

pub fn builder(revert_range: RangeInclusive<u64>) -> BundleBuilder

Return builder instance for further manipulation

pub fn new( state: impl IntoIterator<Item = (Address, Option<AccountInfo>, Option<AccountInfo>, HashMap<Uint<256, 4>, (Uint<256, 4>, Uint<256, 4>)>)>, reverts: impl IntoIterator<Item = impl IntoIterator<Item = (Address, Option<Option<AccountInfo>>, impl IntoIterator<Item = (Uint<256, 4>, Uint<256, 4>)>)>>, contracts: impl IntoIterator<Item = (FixedBytes<32>, Bytecode)>, ) -> BundleState

Create it with new and old values of both Storage and AccountInfo.

pub fn size_hint(&self) -> usize

Returns the approximate size of changes in the bundle state. The estimation is not precise, because the information about the number of destroyed entries that need to be removed is not accessible to the bundle state.

pub fn state(&self) -> &HashMap<Address, BundleAccount>

Return reference to the state.

pub fn is_empty(&self) -> bool

Is bundle state empty.

pub fn len(&self) -> usize

Return number of changed accounts.

pub fn account(&self, address: &Address) -> Option<&BundleAccount>

Get account from state

pub fn bytecode(&self, hash: &FixedBytes<32>) -> Option<Bytecode>

Get bytecode from state

pub fn apply_transitions_and_create_reverts( &mut self, transitions: TransitionState, retention: BundleRetention, )

Consume TransitionState by applying the changes and creating the reverts.

If BundleRetention::includes_reverts is true, then the reverts will be retained.

pub fn into_plain_state( self, is_value_known: OriginalValuesKnown, ) -> StateChangeset

Consume the bundle state and return plain state.

pub fn into_plain_state_and_reverts( self, is_value_known: OriginalValuesKnown, ) -> (StateChangeset, PlainStateReverts)

Consume the bundle state and split it into reverts and plain state.

pub fn extend_state(&mut self, other_state: HashMap<Address, BundleAccount>)

Extend the bundle with other state

Update the other state only if other is not flagged as destroyed.

pub fn extend(&mut self, other: BundleState)

Extend the state with state that is build on top of it.

If storage was wiped in other state, copy this plain state and put it inside other revert (if there is no duplicates of course).

If this and other accounts were both destroyed invalidate second wipe flag (from other). As wiping from database should be done only once and we already transferred all potentially missing storages to the other revert.

pub fn take_n_reverts(&mut self, reverts_to_take: usize) -> Reverts

Take first N raw reverts from the BundleState.

pub fn take_all_reverts(&mut self) -> Reverts

Return and clear all reverts from BundleState

pub fn revert_latest(&mut self) -> bool

Reverts the state changes of the latest transition

Note: This is the same as BundleState::revert(1)

Returns true if the state was reverted.

pub fn revert(&mut self, num_transitions: usize)

Reverts the state changes by N transitions back.

See also Self::revert_latest

pub fn prepend_state(&mut self, other: BundleState)

Prepends present the state with the given BundleState. It adds changes from the given state but does not override any existing changes.

Reverts are not updated.

Trait Implementations

impl Clone for BundleState

fn clone(&self) -> BundleState

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BundleState

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

Formats the value using the given formatter.

impl Default for BundleState

fn default() -> BundleState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BundleState

fn deserialize<__D>( __deserializer: __D, ) -> Result<BundleState, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for BundleState

fn eq(&self, other: &BundleState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BundleState

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for BundleState

impl StructuralPartialEq for BundleState

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 136 bytes