Trait fuel_vm::prelude::InterpreterStorage

source · [−]
pub trait InterpreterStorage: Storage<ContractId, Contract, Error = Self::DataError> + Storage<ContractId, (Salt, Bytes32), Error = Self::DataError> + MerkleStorage<ContractId, AssetId, Word, Error = Self::DataError> + MerkleStorage<ContractId, Bytes32, Bytes32, Error = Self::DataError> {
    type DataError: StdError + Into<Error>;


Show 13 methods    fn block_height(&self) -> Result<u32, Self::DataError>;
    fn timestamp(&self, height: u32) -> Result<Word, Self::DataError>;
    fn block_hash(&self, block_height: u32) -> Result<Bytes32, Self::DataError>;
    fn coinbase(&self) -> Result<Address, Self::DataError>;

    fn storage_contract(
        &self,
        id: &ContractId
    ) -> Result<Option<Cow<'_, Contract>>, Self::DataError> { ... }
    fn storage_contract_insert(
        &mut self,
        id: &ContractId,
        contract: &Contract
    ) -> Result<Option<Contract>, Self::DataError> { ... }
    fn storage_contract_exists(
        &self,
        id: &ContractId
    ) -> Result<bool, Self::DataError> { ... }
    fn storage_contract_root(
        &self,
        id: &ContractId
    ) -> Result<Option<Cow<'_, (Salt, Bytes32)>>, Self::DataError> { ... }
    fn storage_contract_root_insert(
        &mut self,
        id: &ContractId,
        salt: &Salt,
        root: &Bytes32
    ) -> Result<Option<(Salt, Bytes32)>, Self::DataError> { ... }
    fn merkle_contract_state(
        &self,
        id: &ContractId,
        key: &Bytes32
    ) -> Result<Option<Cow<'_, Bytes32>>, Self::DataError> { ... }
    fn merkle_contract_state_insert(
        &mut self,
        contract: &ContractId,
        key: &Bytes32,
        value: &Bytes32
    ) -> Result<Option<Bytes32>, Self::DataError> { ... }
    fn merkle_contract_asset_id_balance(
        &self,
        id: &ContractId,
        asset_id: &AssetId
    ) -> Result<Option<Word>, Self::DataError> { ... }
    fn merkle_contract_asset_id_balance_insert(
        &mut self,
        contract: &ContractId,
        asset_id: &AssetId,
        value: Word
    ) -> Result<Option<Word>, Self::DataError> { ... }

}
Expand description

When this trait is implemented, the underlying interpreter is guaranteed to have full functionality

Required Associated Types

Error implementation for reasons unspecified in the protocol.

Required Methods

Provide the current block height in which the transactions should be executed.

Return the timestamp of a given block

This isn’t optional because the VM is expected to panic if an invalid block height is passed - under the assumption that the block height is consistent, the storage should necessarily have the timestamp for the block, unless some I/O error prevents it from fetching it.

Provide the block hash from a given height.

Provide the coinbase address for the VM instructions implementation.

Provided Methods

Fetch a previously inserted contract code from the chain state for a given contract.

Append a contract to the chain, provided its identifier.

Canonically, the identifier should be Contract::id.

Check if a provided contract exists in the chain.

Fetch a previously inserted salt+root tuple from the chain state for a given contract.

Append the salt+root of a contract that was appended to the chain.

Fetch the value form a key-value mapping in a contract storage.

Insert a key-value mapping in a contract storage.

Fetch the balance of an asset ID in a contract storage.

Update the balance of an asset ID in a contract storage.

Implementations on Foreign Types

Implementors