Trait fuel_vm::storage::InterpreterStorage

source · [−]
pub trait InterpreterStorage: Storage<ContractId, Contract, Error = Self::DataError> + Storage<ContractId, (Salt, Bytes32), Error = Self::DataError> + MerkleStorage<ContractId, Color, Word, Error = Self::DataError> + MerkleStorage<ContractId, Bytes32, Bytes32, Error = Self::DataError> {
    type DataError: StdError + Into<Error>;
    fn block_height(&self) -> Result<u32, 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_color_balance(
        &self, 
        id: &ContractId, 
        color: &Color
    ) -> Result<Option<Word>, Self::DataError> { ... }

    fn merkle_contract_color_balance_insert(
        &mut self, 
        contract: &ContractId, 
        color: &Color, 
        value: Word
    ) -> Result<Option<Word>, Self::DataError> { ... }
}
Expand description

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

Associated Types

Error implementation for reasons unspecified in the protocol.

Required methods

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

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 a color in a contract storage.

Update the balance of a color in a contract storage.

Implementations on Foreign Types

Implementors