Trait InterpreterStorage

pub trait InterpreterStorage:
    StorageWrite<ContractsRawCode, Error = Self::DataError, Error = Self::DataError, Error = Self::DataError, Error = Self::DataError, Error = Self::DataError, Error = Self::DataError, Error = Self::DataError, Error = Self::DataError, Error = Self::DataError, Error = Self::DataError, Error = Self::DataError>
    + StorageSize<ContractsRawCode>
    + StorageRead<ContractsRawCode>
    + StorageWrite<ContractsState>
    + StorageSize<ContractsState>
    + StorageRead<ContractsState>
    + StorageMutate<UploadedBytecodes>
    + StorageWrite<BlobData>
    + StorageSize<BlobData>
    + StorageRead<BlobData>
    + ContractsAssetsStorage {
    type DataError: Into<InterpreterError<Self::DataError>> + Into<RuntimeError<Self::DataError>> + Debug;

    // Required methods
    fn block_height(&self) -> Result<BlockHeight, Self::DataError>;
    fn consensus_parameters_version(&self) -> Result<u32, Self::DataError>;
    fn state_transition_version(&self) -> Result<u32, Self::DataError>;
    fn timestamp(&self, height: BlockHeight) -> Result<u64, Self::DataError>;
    fn block_hash(
        &self,
        block_height: BlockHeight,
    ) -> Result<Bytes32, Self::DataError>;
    fn coinbase(&self) -> Result<ContractId, Self::DataError>;
    fn set_consensus_parameters(
        &mut self,
        version: u32,
        consensus_parameters: &ConsensusParameters,
    ) -> Result<Option<ConsensusParameters>, Self::DataError>;
    fn set_state_transition_bytecode(
        &mut self,
        version: u32,
        hash: &Bytes32,
    ) -> Result<Option<Bytes32>, Self::DataError>;
    fn contract_state_range(
        &self,
        id: &ContractId,
        start_key: &Bytes32,
        range: usize,
    ) -> Result<Vec<Option<Cow<'_, ContractsStateData>>>, Self::DataError>;
    fn contract_state_insert_range<'a, I>(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        values: I,
    ) -> Result<usize, Self::DataError>
       where I: Iterator<Item = &'a [u8]>;
    fn contract_state_remove_range(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        range: usize,
    ) -> Result<Option<()>, Self::DataError>;

    // Provided methods
    fn contains_state_transition_bytecode_root(
        &self,
        root: &Bytes32,
    ) -> Result<bool, Self::DataError> { ... }
    fn deploy_contract_with_id(
        &mut self,
        slots: &[StorageSlot],
        contract: &Contract,
        id: &ContractId,
    ) -> Result<(), Self::DataError> { ... }
    fn storage_contract(
        &self,
        id: &ContractId,
    ) -> Result<Option<Cow<'_, Contract>>, Self::DataError> { ... }
    fn storage_contract_size(
        &self,
        id: &ContractId,
    ) -> Result<Option<usize>, Self::DataError> { ... }
    fn read_contract(
        &self,
        id: &ContractId,
        writer: &mut [u8],
    ) -> Result<Option<u64>, Self::DataError> { ... }
    fn storage_contract_insert(
        &mut self,
        id: &ContractId,
        contract: &Contract,
    ) -> Result<(), Self::DataError> { ... }
    fn storage_contract_exists(
        &self,
        id: &ContractId,
    ) -> Result<bool, Self::DataError> { ... }
    fn contract_state(
        &self,
        id: &ContractId,
        key: &Bytes32,
    ) -> Result<Option<Cow<'_, ContractsStateData>>, Self::DataError> { ... }
    fn contract_state_insert(
        &mut self,
        contract: &ContractId,
        key: &Bytes32,
        value: &[u8],
    ) -> Result<(), Self::DataError> { ... }
    fn contract_state_replace(
        &mut self,
        contract: &ContractId,
        key: &Bytes32,
        value: &[u8],
    ) -> Result<Option<Vec<u8>>, Self::DataError> { ... }
}

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

Required Associated Types

type DataError: Into<InterpreterError<Self::DataError>> + Into<RuntimeError<Self::DataError>> + Debug

Error implementation for reasons unspecified in the protocol.

Required Methods

fn block_height(&self) -> Result<BlockHeight, Self::DataError>

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

fn consensus_parameters_version(&self) -> Result<u32, Self::DataError>

Provide the current version of consensus parameters used to execute transaction.

fn state_transition_version(&self) -> Result<u32, Self::DataError>

Provide the current version of state transition function used to execute transaction.

fn timestamp(&self, height: BlockHeight) -> Result<u64, Self::DataError>

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.

fn block_hash( &self, block_height: BlockHeight, ) -> Result<Bytes32, Self::DataError>

Provide the block hash from a given height.

fn coinbase(&self) -> Result<ContractId, Self::DataError>

Provide the coinbase address for the VM instructions implementation.

fn set_consensus_parameters( &mut self, version: u32, consensus_parameters: &ConsensusParameters, ) -> Result<Option<ConsensusParameters>, Self::DataError>

Set the consensus parameters in the storage under the version.

Returns the previous consensus parameters if they were set.

fn set_state_transition_bytecode( &mut self, version: u32, hash: &Bytes32, ) -> Result<Option<Bytes32>, Self::DataError>

Set the state transition bytecode in the storage under the version.

Returns the previous bytecode if it was set.

fn contract_state_range( &self, id: &ContractId, start_key: &Bytes32, range: usize, ) -> Result<Vec<Option<Cow<'_, ContractsStateData>>>, 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 contract_state_insert_range<'a, I>( &mut self, contract: &ContractId, start_key: &Bytes32, values: I, ) -> Result<usize, Self::DataError>

where I: Iterator<Item = &'a [u8]>,

Insert a range of key-value mappings into contract storage. Returns the number of keys that were previously unset but are now set.

fn contract_state_remove_range( &mut self, contract: &ContractId, start_key: &Bytes32, range: usize, ) -> 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.

Provided Methods

fn contains_state_transition_bytecode_root( &self, root: &Bytes32, ) -> Result<bool, Self::DataError>

Returns true if the fully uploaded state transition bytecode is present in the storage.

fn deploy_contract_with_id( &mut self, slots: &[StorageSlot], contract: &Contract, 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_size( &self, id: &ContractId, ) -> Result<Option<usize>, Self::DataError>

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

fn read_contract( &self, id: &ContractId, writer: &mut [u8], ) -> Result<Option<u64>, Self::DataError>

Read contract bytes from storage into the buffer.

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

Append a contract to the chain, provided its identifier.

Canonically, the identifier should be Contract::id.

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

Check if a provided contract exists in the chain.

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

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

fn contract_state_insert( &mut self, contract: &ContractId, key: &Bytes32, value: &[u8], ) -> Result<(), Self::DataError>

Insert a key-value mapping in a contract storage.

fn contract_state_replace( &mut self, contract: &ContractId, key: &Bytes32, value: &[u8], ) -> Result<Option<Vec<u8>>, Self::DataError>

Insert a key-value mapping into a contract storage.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<S> InterpreterStorage for &mut S

where S: InterpreterStorage,

type DataError = <S as InterpreterStorage>::DataError

fn block_height( &self, ) -> Result<BlockHeight, <&mut S as InterpreterStorage>::DataError>

fn consensus_parameters_version( &self, ) -> Result<u32, <&mut S as InterpreterStorage>::DataError>

fn state_transition_version( &self, ) -> Result<u32, <&mut S as InterpreterStorage>::DataError>

fn timestamp( &self, height: BlockHeight, ) -> Result<u64, <&mut S as InterpreterStorage>::DataError>

fn block_hash( &self, block_height: BlockHeight, ) -> Result<Bytes32, <&mut S as InterpreterStorage>::DataError>

fn coinbase( &self, ) -> Result<ContractId, <&mut S as InterpreterStorage>::DataError>

fn set_consensus_parameters( &mut self, version: u32, consensus_parameters: &ConsensusParameters, ) -> Result<Option<ConsensusParameters>, <&mut S as InterpreterStorage>::DataError>

fn set_state_transition_bytecode( &mut self, version: u32, hash: &Bytes32, ) -> Result<Option<Bytes32>, <&mut S as InterpreterStorage>::DataError>

fn storage_contract_size( &self, id: &ContractId, ) -> Result<Option<usize>, <&mut S as InterpreterStorage>::DataError>

fn read_contract( &self, id: &ContractId, writer: &mut [u8], ) -> Result<Option<u64>, <&mut S as InterpreterStorage>::DataError>

fn contract_state_range( &self, id: &ContractId, start_key: &Bytes32, range: usize, ) -> Result<Vec<Option<Cow<'_, ContractsStateData>>>, <&mut S as InterpreterStorage>::DataError>

fn contract_state_insert_range<'a, I>( &mut self, contract: &ContractId, start_key: &Bytes32, values: I, ) -> Result<usize, <&mut S as InterpreterStorage>::DataError>

where I: Iterator<Item = &'a [u8]>,

fn contract_state_remove_range( &mut self, contract: &ContractId, start_key: &Bytes32, range: usize, ) -> Result<Option<()>, <&mut S as InterpreterStorage>::DataError>

Implementors

impl<D> InterpreterStorage for PredicateStorage<D>

where D: PredicateStorageRequirements,

type DataError = PredicateStorageError

impl<D> InterpreterStorage for VmStorage<D>

where D: StorageWrite<ContractsRawCode, Error = Error> + StorageSize<ContractsRawCode, Error = Error> + StorageRead<ContractsRawCode, Error = Error> + StorageMutate<ContractsAssets, Error = Error> + StorageWrite<ContractsState, Error = Error> + StorageSize<ContractsState, Error = Error> + StorageRead<ContractsState, Error = Error> + StorageMutate<ConsensusParametersVersions, Error = Error> + StorageMutate<StateTransitionBytecodeVersions, Error = Error> + StorageMutate<UploadedBytecodes, Error = Error> + StorageWrite<BlobData, Error = Error> + StorageSize<BlobData, Error = Error> + StorageRead<BlobData, Error = Error> + VmStorageRequirements<Error = Error>,

type DataError = Error