Struct fuel_vm::storage::PredicateStorage

pub struct PredicateStorage;

No-op storage used for predicate operations.

The storage implementations are expected to provide KV-like operations for contract operations. However, predicates, as defined in the protocol, cannot execute contract opcodes. This means its storage backend for predicate execution shouldn’t provide any functionality.

Trait Implementations

impl Clone for PredicateStorage

fn clone(&self) -> PredicateStorage

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PredicateStorage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PredicateStorage

fn default() -> PredicateStorage

Returns the “default value” for a type.

impl InterpreterStorage for PredicateStorage

type DataError = InterpreterError

Error implementation for reasons unspecified in the protocol.

fn block_height(&self) -> Result<u32, InterpreterError>

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

fn timestamp(&self, _height: u32) -> Result<Word, Self::DataError>

Return the timestamp of a given block

fn block_hash(&self, _block_height: u32) -> Result<Bytes32, InterpreterError>

Provide the block hash from a given height.

fn coinbase(&self) -> Result<Address, InterpreterError>

Provide the coinbase address for the VM instructions implementation.

fn merkle_contract_state_range(
    &self,
    _id: &ContractId,
    _start_key: &Bytes32,
    _range: Word
) -> Result<Vec<Option<Cow<'_, Bytes32>>>, Self::DataError>

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.

fn merkle_contract_state_insert_range(
    &mut self,
    _contract: &ContractId,
    _start_key: &Bytes32,
    _values: &[Bytes32]
) -> Result<Option<()>, Self::DataError>

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

fn merkle_contract_state_remove_range(
    &mut self,
    _contract: &ContractId,
    _start_key: &Bytes32,
    _range: Word
) -> Result<Option<()>, Self::DataError>

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

fn deploy_contract(
    &mut self,
    salt: &Salt,
    slots: &[StorageSlot],
    contract: &Contract
) -> Result<(), Self::DataError>

Deploy a contract into the storage

fn deploy_contract_with_id(
    &mut self,
    salt: &Salt,
    slots: &[StorageSlot],
    contract: &Contract,
    root: &Bytes32,
    id: &ContractId
) -> Result<(), Self::DataError>

Deploy a contract into the storage with contract id

fn storage_contract(
    &self,
    id: &ContractId
) -> Result<Option<Cow<'_, Contract>>, Self::DataError>

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

fn storage_contract_insert(
    &mut self,
    id: &ContractId,
    contract: &Contract
) -> Result<Option<Contract>, Self::DataError>

Append a contract to the chain, provided its identifier.

fn storage_contract_exists(
    &self,
    id: &ContractId
) -> Result<bool, Self::DataError>

Check if a provided contract exists in the chain.

fn storage_contract_root(
    &self,
    id: &ContractId
) -> Result<Option<Cow<'_, (Salt, Bytes32)>>, Self::DataError>

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

fn storage_contract_root_insert(
    &mut self,
    id: &ContractId,
    salt: &Salt,
    root: &Bytes32
) -> Result<Option<(Salt, Bytes32)>, Self::DataError>

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

fn merkle_contract_state(
    &self,
    id: &ContractId,
    key: &Bytes32
) -> Result<Option<Cow<'_, Bytes32>>, Self::DataError>

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

fn merkle_contract_state_insert(
    &mut self,
    contract: &ContractId,
    key: &Bytes32,
    value: &Bytes32
) -> Result<Option<Bytes32>, Self::DataError>

Insert a key-value mapping in a contract storage.

fn merkle_contract_state_remove(
    &mut self,
    contract: &ContractId,
    key: &Bytes32
) -> Result<Option<Bytes32>, Self::DataError>

Remove a key-value mapping from a contract storage.

fn merkle_contract_asset_id_balance(
    &self,
    id: &ContractId,
    asset_id: &AssetId
) -> Result<Option<Word>, Self::DataError>

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

fn merkle_contract_asset_id_balance_insert(
    &mut self,
    contract: &ContractId,
    asset_id: &AssetId,
    value: Word
) -> Result<Option<Word>, Self::DataError>

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

impl<Key, Type: Mappable> MerkleRootStorage<Key, Type> for PredicateStorage

fn root(&mut self, _parent: &Key) -> Result<MerkleRoot, InterpreterError>

Return the merkle root of the stored Type in the storage.

impl<Type: Mappable> StorageInspect<Type> for PredicateStorage

type Error = InterpreterError

fn get(
    &self,
    _key: &Type::Key
) -> Result<Option<Cow<'_, Type::GetValue>>, InterpreterError>

Retrieve Cow<Value> such as Key->Value.

fn contains_key(&self, _key: &Type::Key) -> Result<bool, InterpreterError>

Return true if there is a Key mapping to a value in the storage.

impl<Type: Mappable> StorageMutate<Type> for PredicateStorage

fn insert(
    &mut self,
    _key: &Type::Key,
    _value: &Type::SetValue
) -> Result<Option<Type::GetValue>, InterpreterError>

Append Key->Value mapping to the storage.

fn remove(
    &mut self,
    _key: &Type::Key
) -> Result<Option<Type::GetValue>, InterpreterError>

Remove Key->Value mapping from the storage.

impl Copy for PredicateStorage