Struct StateTreeV4 

pub struct StateTreeV4<S> {
    hamt: HamtImpl<S, ActorState>,
    version: StateTreeVersion,
    info: Option<Cid<64>>,
    actor_cache: RefCell<HistoryMap<u64, ActorCacheEntry>>,
    resolve_cache: RefCell<HistoryMap<Address, u64>>,
    layers: Vec<StateSnapLayer>,
}

State tree implementation using hamt. This structure is not threadsafe and should only be used in sync contexts.

Fields

hamt: HamtImpl<S, ActorState>

version: StateTreeVersion

info: Option<Cid<64>>

actor_cache: RefCell<HistoryMap<u64, ActorCacheEntry>>

resolve_cache: RefCell<HistoryMap<Address, u64>>

layers: Vec<StateSnapLayer>

Implementations

impl<S> StateTree<S>

where S: Blockstore,

pub fn new( store: S, version: StateTreeVersion, ) -> Result<StateTree<S>, ExecutionError>

pub fn new_from_root( store: S, c: &Cid<64>, ) -> Result<StateTree<S>, ExecutionError>

Constructor for a hamt state tree given an IPLD store

pub fn store(&self) -> &S

Retrieve store reference to modify db.

pub fn get_actor(&self, id: u64) -> Result<Option<ActorState>, ExecutionError>

Get actor state from an actor ID.

pub fn set_actor(&mut self, id: u64, actor: ActorState)

Set actor state with an actor ID.

pub fn lookup_id(&self, addr: &Address) -> Result<Option<u64>, ExecutionError>

Get an ID address from any Address

pub fn delete_actor(&mut self, id: u64)

Delete actor identified by the supplied ID.

pub fn mutate_actor<F>( &mut self, id: u64, mutate: F, ) -> Result<(), ExecutionError>

where F: FnOnce(&mut ActorState) -> Result<(), ExecutionError>,

Mutate and set actor state identified by the supplied ID. Returns a fatal error if the actor doesn’t exist.

pub fn maybe_mutate_actor_id<F>( &mut self, id: u64, mutate: F, ) -> Result<bool, ExecutionError>

where F: FnOnce(&mut ActorState) -> Result<(), ExecutionError>,

Try to mutate the actor state identified by the supplied ID, returning false if the actor doesn’t exist.

pub fn register_new_address( &mut self, addr: &Address, ) -> Result<u64, ExecutionError>

Register a new address through the init actor.

pub fn begin_transaction(&mut self)

Begin a new state transaction. Transactions stack.

pub fn end_transaction(&mut self, revert: bool) -> Result<(), ExecutionError>

End a transaction, reverting if requested.

pub fn in_transaction(&self) -> bool

Returns true if we’re inside of a transaction.

pub fn flush(&mut self) -> Result<Cid<64>, ExecutionError>

Flush state tree and return Cid root.

pub fn into_store(self) -> S

Consumes this StateTree and returns the Blockstore it owns via the HAMT.

pub fn for_each<F>(&self, f: F) -> Result<(), Error>

where F: FnMut(Address, &ActorState) -> Result<(), Error>,