Struct forest_filecoin::shim::fvm_latest::kernel::filecoin::DefaultFilecoinKernel

pub struct DefaultFilecoinKernel<C>(pub DefaultKernel<C>);

Tuple Fields

0: DefaultKernel<C>

Trait Implementations

impl<C> ActorOps for DefaultFilecoinKernel<C>

where C: CallManager, DefaultKernel<C>: ActorOps,

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 lookup_delegated_address( &self, actor_id: u64, ) -> Result<Option<Address>, ExecutionError>

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

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_cid: 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_cid: 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

impl<C> CryptoOps for DefaultFilecoinKernel<C>

where C: CallManager, DefaultKernel<C>: CryptoOps,

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 DefaultFilecoinKernel<C>

where C: CallManager, DefaultKernel<C>: DebugOps,

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 DefaultFilecoinKernel<C>

where C: CallManager, DefaultKernel<C>: EventOps,

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

Records an event emitted throughout execution.

impl<C> FilecoinKernel for DefaultFilecoinKernel<C>

where C: CallManager, DefaultFilecoinKernel<C>: Kernel,

fn verify_post( &self, verify_info: &WindowPoStVerifyInfo, ) -> Result<bool, ExecutionError>

Verifies a window proof of spacetime.

fn compute_unsealed_sector_cid( &self, proof_type: RegisteredSealProof, pieces: &[PieceInfo], ) -> Result<Cid<64>, ExecutionError>

Computes an unsealed sector CID (CommD) from its constituent piece CIDs (CommPs) and sizes.

fn verify_consensus_fault( &self, h1: &[u8], h2: &[u8], extra: &[u8], ) -> Result<Option<ConsensusFault>, ExecutionError>

Verifies that two block headers provide proof of a consensus fault:

fn batch_verify_seals( &self, vis: &[SealVerifyInfo], ) -> Result<Vec<bool>, ExecutionError>

Verifies a batch of seals. This is a privledged syscall, may only be called by the power actor during cron.

fn verify_aggregate_seals( &self, aggregate: &AggregateSealVerifyProofAndInfos, ) -> Result<bool, ExecutionError>

Verify aggregate seals verifies an aggregated batch of prove-commits.

fn verify_replica_update( &self, replica: &ReplicaUpdateInfo, ) -> Result<bool, ExecutionError>

Verify replica update verifies a snap deal: an upgrade from a CC sector to a sector with deals.

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

Returns the total token supply in circulation at the beginning of the current epoch. The circulating supply is the sum of:

impl<C> IpldBlockOps for DefaultFilecoinKernel<C>

where C: CallManager, DefaultKernel<C>: IpldBlockOps,

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 DefaultFilecoinKernel<C>

where C: CallManager,

type CallManager = C

The Kernel’s CallManager is

type Limiter = <DefaultKernel<C> as Kernel>::Limiter

The Kernel’s memory allocation tracker.

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

where DefaultFilecoinKernel<C>: Sized,

Consume the Kernel and return the underlying CallManager and BlockRegistry.

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

The kernel’s underlying “machine”.

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

Construct a new Kernel from the given CallManager.

fn limiter_mut(&mut self) -> &mut <DefaultFilecoinKernel<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 DefaultFilecoinKernel<C>

where C: CallManager, DefaultKernel<C>: MessageOps,

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

Message information.

impl<C> NetworkOps for DefaultFilecoinKernel<C>

where C: CallManager, DefaultKernel<C>: NetworkOps,

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 DefaultFilecoinKernel<C>

where C: CallManager, DefaultKernel<C>: RandomnessOps,

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 DefaultFilecoinKernel<C>

where C: CallManager, DefaultKernel<C>: SelfOps,

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

Get the state root.

fn set_root(&mut self, root: 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, C> SendOps<K> for DefaultFilecoinKernel<C>

where K: FilecoinKernel, DefaultKernel<C>: SendOps<K>,

fn send( &mut self, recipient: &Address, method: u64, params: 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 DefaultFilecoinKernel<<K as Kernel>::CallManager>

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

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

impl<K, C> UpgradeOps<K> for DefaultFilecoinKernel<C>

where K: FilecoinKernel, DefaultKernel<C>: UpgradeOps<K>,

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.