Trait ContractInterface 

pub trait ContractInterface {
    // Required methods
    fn validate_state(
        parameters: Parameters<'static>,
        state: State<'static>,
        related: RelatedContracts<'static>,
    ) -> Result<ValidateResult, ContractError>;
    fn validate_delta(
        parameters: Parameters<'static>,
        delta: StateDelta<'static>,
    ) -> Result<bool, ContractError>;
    fn update_state(
        parameters: Parameters<'static>,
        state: State<'static>,
        data: Vec<UpdateData<'static>>,
    ) -> Result<UpdateModification<'static>, ContractError>;
    fn summarize_state(
        parameters: Parameters<'static>,
        state: State<'static>,
    ) -> Result<StateSummary<'static>, ContractError>;
    fn get_state_delta(
        parameters: Parameters<'static>,
        state: State<'static>,
        summary: StateSummary<'static>,
    ) -> Result<StateDelta<'static>, ContractError>;
}

Trait to implement for the contract building.

Contains all necessary methods to interact with the contract.

Examples

Implementing ContractInterface on a type:

struct Contract;

#[contract]
impl ContractInterface for Contract {
    fn validate_state(
        _parameters: Parameters<'static>,
        _state: State<'static>,
        _related: RelatedContracts
    ) -> Result<ValidateResult, ContractError> {
        Ok(ValidateResult::Valid)
    }

    fn validate_delta(
        _parameters: Parameters<'static>,
        _delta: StateDelta<'static>
    ) -> Result<bool, ContractError> {
        Ok(true)
    }

    fn update_state(
        _parameters: Parameters<'static>,
        state: State<'static>,
        _data: Vec<UpdateData>,
    ) -> Result<UpdateModification<'static>, ContractError> {
        Ok(UpdateModification::valid(state))
    }

    fn summarize_state(
        _parameters: Parameters<'static>,
        _state: State<'static>,
    ) -> Result<StateSummary<'static>, ContractError> {
        Ok(StateSummary::from(vec![]))
    }

    fn get_state_delta(
        _parameters: Parameters<'static>,
        _state: State<'static>,
        _summary: StateSummary<'static>,
    ) -> Result<StateDelta<'static>, ContractError> {
        Ok(StateDelta::from(vec![]))
    }
}

Required Methods

fn validate_state( parameters: Parameters<'static>, state: State<'static>, related: RelatedContracts<'static>, ) -> Result<ValidateResult, ContractError>

Verify that the state is valid, given the parameters.

fn validate_delta( parameters: Parameters<'static>, delta: StateDelta<'static>, ) -> Result<bool, ContractError>

Verify that a delta is valid if possible, returns false if and only delta is definitely invalid, true otherwise.

fn update_state( parameters: Parameters<'static>, state: State<'static>, data: Vec<UpdateData<'static>>, ) -> Result<UpdateModification<'static>, ContractError>

Update the state to account for the new data

fn summarize_state( parameters: Parameters<'static>, state: State<'static>, ) -> Result<StateSummary<'static>, ContractError>

Generate a concise summary of a state that can be used to create deltas relative to this state.

fn get_state_delta( parameters: Parameters<'static>, state: State<'static>, summary: StateSummary<'static>, ) -> Result<StateDelta<'static>, ContractError>

Generate a state delta using a summary from the current state. This along with Self::summarize_state allows flexible and efficient state synchronization between peers.

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.

Implementors