Struct DefaultCallManager 

#[repr(transparent)]
pub struct DefaultCallManager<M>(Option<Box<InnerDefaultCallManager<M>>>)
where
    M: Machine;

The default CallManager implementation.

Tuple Fields

0: Option<Box<InnerDefaultCallManager<M>>>

Trait Implementations

impl<M> CallManager for DefaultCallManager<M>

where M: Machine,

fn resolve_address( &self, address: &Address, ) -> Result<Option<u64>, ExecutionError>

Resolve an address and charge for it.

type Machine = M

The underlying Machine on top of which this CallManager executes.

fn new( machine: M, engine: Engine, gas_limit: u64, origin: u64, origin_address: Address, receiver: Option<u64>, receiver_address: Address, nonce: u64, gas_premium: TokenAmount, ) -> DefaultCallManager<M>

Construct a new call manager.

fn limiter_mut( &mut self, ) -> &mut <<DefaultCallManager<M> as CallManager>::Machine as Machine>::Limiter

Limit memory usage throughout a message execution.

fn call_actor<K>( &mut self, from: u64, to: Address, entrypoint: Entrypoint, params: Option<Block>, value: &TokenAmount, gas_limit: Option<Gas>, read_only: bool, ) -> Result<InvocationResult, ExecutionError>

where K: Kernel<CallManager = DefaultCallManager<M>>,

Calls an actor at the given address and entrypoint. The type parameter K specifies the the kernel on top of which the target actor should execute.

fn with_transaction( &mut self, f: impl FnOnce(&mut DefaultCallManager<M>) -> Result<InvocationResult, ExecutionError>, ) -> Result<InvocationResult, ExecutionError>

Execute some operation (usually a call_actor) within a transaction.

fn finish( self, ) -> (Result<FinishRet, ExecutionError>, <DefaultCallManager<M> as CallManager>::Machine)

Finishes execution, returning the gas used, machine, and exec trace if requested.

fn machine(&self) -> &<DefaultCallManager<M> as CallManager>::Machine

Returns a reference to the machine.

fn machine_mut( &mut self, ) -> &mut <DefaultCallManager<M> as CallManager>::Machine

Returns a mutable reference to the machine.

fn engine(&self) -> &Engine

Returns a reference to the engine

fn gas_tracker(&self) -> &GasTracker

Returns a reference to the gas tracker.

fn gas_premium(&self) -> &TokenAmount

Returns the gas premium paid by the currently executing message.

fn origin(&self) -> u64

Getter for origin actor.

fn nonce(&self) -> u64

Getter for message nonce.

fn get_call_stack(&self) -> &[(u64, &'static str)]

fn next_actor_address(&self) -> Address

Get the actor address (f2) that will should be assigned to the next actor created.

fn create_actor( &mut self, code_id: Cid<64>, actor_id: u64, delegated_address: Option<Address>, ) -> Result<(), ExecutionError>

Create a new actor with the given code CID, actor ID, and delegated address. This method does not register the actor with the init actor. It just creates it in the state-tree.

fn append_event(&mut self, evt: StampedEvent)

Appends an event to the event accumulator.

fn invocation_count(&self) -> u64

Gets the total invocations done on this call stack.

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

Looks up an actor in the state-tree, charging gas as appropriate.

fn set_actor( &mut self, id: u64, state: ActorState, ) -> Result<(), ExecutionError>

Sets an actor in the state-tree, charging gas as appropriate. Use create_actor if you want to create a new actor.

fn delete_actor(&mut self, id: u64) -> Result<(), ExecutionError>

Deletes an actor from the state-tree, charging gas as appropriate.

fn transfer( &mut self, from: u64, to: u64, value: &TokenAmount, ) -> Result<(), ExecutionError>

Transfers tokens from one actor to another, charging gas as appropriate.

fn log(&mut self, msg: String)

log

fn trace_ipld(&mut self, op: IpldOperation, cid: Cid<64>, size: usize)

fn price_list(&self) -> &PriceList

Returns the current price list.

fn context(&self) -> &MachineContext

Returns the machine context.

fn blockstore(&self) -> &<Self::Machine as Machine>::Blockstore

Returns the blockstore.

fn externs(&self) -> &<Self::Machine as Machine>::Externs

Returns the externs.

fn charge_gas(&self, charge: GasCharge) -> Result<GasTimer, ExecutionError>

Charge gas.