Trait fuel_vm::storage::InterpreterStorage

source · 
pub trait InterpreterStorage: StorageMutate<ContractsRawCode, Error = Self::DataError> + StorageMutate<ContractsInfo, Error = Self::DataError> + for<'a> MerkleRootStorage<ContractId, ContractsAssets<'a>, Error = Self::DataError> + for<'a> MerkleRootStorage<ContractId, ContractsState<'a>, Error = Self::DataError> + Sized {
    type DataError: StdError + Into<Error>;


Show 19 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 merkle_contract_state_range(
        &self,
        id: &ContractId,
        start_key: &Bytes32,
        range: Word
    ) -> Result<Vec<Option<Cow<'_, Bytes32>>>, Self::DataError>;
    fn merkle_contract_state_insert_range(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        values: &[Bytes32]
    ) -> Result<Option<()>, Self::DataError>;
    fn merkle_contract_state_remove_range(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        range: Word
    ) -> Result<Option<()>, Self::DataError>;

    fn deploy_contract(
        &mut self,
        salt: &Salt,
        slots: &[StorageSlot],
        contract: &Contract
    ) -> Result<(), Self::DataError> { ... }
    fn deploy_contract_with_id(
        &mut self,
        salt: &Salt,
        slots: &[StorageSlot],
        contract: &Contract,
        root: &Bytes32,
        id: &ContractId
    ) -> Result<(), 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_state_remove(
        &mut self,
        contract: &ContractId,
        key: &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.

Fetch a range of values from a key-value mapping in a contract storage. Returns the full range requested using optional values in case a requested slot is unset.

Insert a range of key-value mappings into contract storage. Returns None if any of the keys in the range were previously unset.

Remove a range of key-values from contract storage. Returns None if any of the keys in the range were already unset.

Provided Methods§

Deploy a contract into the storage

Deploy a contract into the storage with contract id

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.

Remove a key-value mapping from 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§