Struct forest_filecoin::shim::fvm_latest::DefaultKernel

pub struct DefaultKernel<C> {
    pub caller: u64,
    pub actor_id: u64,
    pub method: u64,
    pub value_received: TokenAmount,
    pub read_only: bool,
    pub call_manager: C,
    pub blocks: BlockRegistry,
}

The “default” Kernel implementation.

Fields

caller: u64

actor_id: u64

method: u64

value_received: TokenAmount

read_only: bool

call_manager: C

The call manager for this call stack. If this kernel calls another actor, it will temporarily “give” the call manager to the other kernel before re-attaching it.

blocks: BlockRegistry

Tracks block data and organizes it through index handles so it can be referred to.

This does not yet reason about reachability.

Trait Implementations

impl<C> ActorOps for DefaultKernel<C>

where C: CallManager,

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

Resolves an address of any protocol to an ID address (via the Init actor’s table). This allows resolution of externally-provided SECP, BLS, or actor addresses to the canonical form. If the argument is an ID address it is returned directly.

fn get_actor_code_cid(&self, id: u64) -> Result<Cid<64>, ExecutionError>

Look up the code CID of an actor.

fn next_actor_address(&self) -> Result<Address, ExecutionError>

Computes an address for a new actor. The returned address is intended to uniquely refer to the actor even in the event of a chain re-org (whereas an ID-address might refer to a different actor after messages are re-ordered). Always an ActorExec address.

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

Creates an actor with given code_cid, actor_id, delegated_address (if specified), and an empty state.

fn install_actor(&mut self, code_id: Cid<64>) -> Result<(), ExecutionError>

fn get_builtin_actor_type( &self, code_cid: &Cid<64>, ) -> Result<u32, ExecutionError>

Returns the actor’s “type” (if builitin) or 0 (if not).

fn get_code_cid_for_type(&self, typ: u32) -> Result<Cid<64>, ExecutionError>

Returns the CodeCID for the supplied built-in actor type.

fn balance_of(&self, actor_id: u64) -> Result<TokenAmount, ExecutionError>

Returns the balance associated with an actor id

fn lookup_delegated_address( &self, actor_id: u64, ) -> Result<Option<Address>, ExecutionError>

Looks up the “delegated” (f4) address of the specified actor, if any.

impl<C> CryptoOps for DefaultKernel<C>

where C: CallManager,

fn verify_signature( &self, sig_type: SignatureType, signature: &[u8], signer: &Address, plaintext: &[u8], ) -> Result<bool, ExecutionError>

Verifies that a signature is valid for an address and plaintext.

fn verify_bls_aggregate( &self, aggregate_sig: &[u8; 96], pub_keys: &[[u8; 48]], plaintexts_concat: &[u8], plaintext_lens: &[u32], ) -> Result<bool, ExecutionError>

Verifies a BLS aggregate signature. In the case where there is one signer/signed plaintext, this is equivalent to verifying a non-aggregated BLS signature.

fn recover_secp_public_key( &self, hash: &[u8; 32], signature: &[u8; 65], ) -> Result<[u8; 65], ExecutionError>

Given a message hash and its signature, recovers the public key of the signer.

fn hash(&self, code: u64, data: &[u8]) -> Result<Multihash<64>, ExecutionError>

Hashes input data_in using with the specified hash function, writing the output to digest_out, returning the size of the digest written to digest_out. If digest_out is to small to fit the entire digest, it will be truncated. If too large, the leftover space will not be overwritten.

impl<C> DebugOps for DefaultKernel<C>

where C: CallManager,

fn log(&self, msg: String)

Log a message.

fn debug_enabled(&self) -> bool

Returns whether debug mode is enabled.

fn store_artifact(&self, name: &str, data: &[u8]) -> Result<(), ExecutionError>

Store an artifact. Returns error on malformed name, returns Ok and logs the error on system/os errors.

impl<C> EventOps for DefaultKernel<C>

where C: CallManager,

fn emit_event( &mut self, event_headers: &[EventEntry], event_keys: &[u8], event_values: &[u8], ) -> Result<(), ExecutionError>

Records an event emitted throughout execution.

impl<C> IpldBlockOps for DefaultKernel<C>

where C: CallManager,

fn block_open( &mut self, cid: &Cid<64>, ) -> Result<(u32, BlockStat), ExecutionError>

Open a block.

fn block_create( &mut self, codec: u64, data: &[u8], ) -> Result<u32, ExecutionError>

Create a new block.

fn block_link( &mut self, id: u32, hash_fun: u64, hash_len: u32, ) -> Result<Cid<64>, ExecutionError>

Computes a CID for a block.

fn block_read( &self, id: u32, offset: u32, buf: &mut [u8], ) -> Result<i32, ExecutionError>

Read data from a block.

fn block_stat(&self, id: u32) -> Result<BlockStat, ExecutionError>

Returns the blocks codec & size.

impl<C> Kernel for DefaultKernel<C>

where C: CallManager,

type CallManager = C

The Kernel’s CallManager is

type Limiter = <<C as CallManager>::Machine as Machine>::Limiter

The Kernel’s memory allocation tracker.

fn into_inner( self, ) -> (<DefaultKernel<C> as Kernel>::CallManager, BlockRegistry)

where DefaultKernel<C>: Sized,

Consume the Kernel and return the underlying CallManager and BlockRegistry.

fn new( mgr: C, blocks: BlockRegistry, caller: u64, actor_id: u64, method: u64, value_received: TokenAmount, read_only: bool, ) -> DefaultKernel<C>

Construct a new Kernel from the given CallManager.

fn machine( &self, ) -> &<<DefaultKernel<C> as Kernel>::CallManager as CallManager>::Machine

The kernel’s underlying “machine”.

fn limiter_mut(&mut self) -> &mut <DefaultKernel<C> as Kernel>::Limiter

Give access to the limiter of the underlying call manager.

fn gas_available(&self) -> Gas

Returns the remaining gas for the transaction.

fn charge_gas( &self, name: &str, compute: Gas, ) -> Result<GasTimer, ExecutionError>

ChargeGas charges specified amount of gas for execution. name provides information about gas charging point.

impl<C> MessageOps for DefaultKernel<C>

where C: CallManager,

fn msg_context(&self) -> Result<MessageContext, ExecutionError>

Message information.

impl<C> NetworkOps for DefaultKernel<C>

where C: CallManager,

fn network_context(&self) -> Result<NetworkContext, ExecutionError>

Network information (epoch, version, etc.).

fn tipset_cid(&self, epoch: i64) -> Result<Cid<64>, ExecutionError>

The CID of the tipset at the specified epoch.

impl<C> RandomnessOps for DefaultKernel<C>

where C: CallManager,

fn get_randomness_from_tickets( &self, rand_epoch: i64, ) -> Result<[u8; 32], ExecutionError>

Randomness returns a (pseudo)random byte array drawing from the latest ticket chain from a given epoch. This randomness is fork dependant but also biasable because of this.

fn get_randomness_from_beacon( &self, rand_epoch: i64, ) -> Result<[u8; 32], ExecutionError>

Randomness returns a (pseudo)random byte array drawing from the latest beacon from a given epoch. This randomness is not tied to any fork of the chain, and is unbiasable.

impl<C> SelfOps for DefaultKernel<C>

where C: CallManager,

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

Get the state root.

fn set_root(&mut self, new: Cid<64>) -> Result<(), ExecutionError>

Update the state-root.

fn current_balance(&self) -> Result<TokenAmount, ExecutionError>

The balance of the receiver.

fn self_destruct(&mut self, burn_unspent: bool) -> Result<(), ExecutionError>

Deletes the executing actor from the state tree, burning any remaining balance if requested.

impl<K> SendOps<K> for DefaultKernel<<K as Kernel>::CallManager>

where K: Kernel,

fn send( &mut self, recipient: &Address, method: u64, params_id: u32, value: &TokenAmount, gas_limit: Option<Gas>, flags: SendFlags, ) -> Result<CallResult, ExecutionError>

Sends a message to another actor. The method type parameter K is the type of the kernel to instantiate for the receiving actor. This is necessary to support wrapping a kernel, so the outer kernel can specify its Self as the receiver’s kernel type, rather than the wrapped kernel specifying its Self. This method is part of the Kernel trait so it can refer to the Self::CallManager associated type necessary to constrain K.

impl<K> SyscallHandler<K> for DefaultKernel<<K as Kernel>::CallManager>

where K: Kernel + ActorOps + IpldBlockOps + SendOps + UpgradeOps + CryptoOps + DebugOps + EventOps + MessageOps + NetworkOps + RandomnessOps + SelfOps,

fn link_syscalls(linker: &mut Linker<K>) -> Result<(), Error>

impl<K> UpgradeOps<K> for DefaultKernel<<K as Kernel>::CallManager>

where K: Kernel,

fn upgrade_actor( &mut self, new_code_cid: Cid<64>, params_id: u32, ) -> Result<CallResult, ExecutionError>

Upgrades the running actor to the specified code CID.