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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so 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