pub trait HasHost<State>: Sized {
    type StateApiType: HasStateApi;
    type ReturnValueType: HasCallResponse + Debug;

    fn invoke_transfer(
        &self,
        receiver: &AccountAddress,
        amount: Amount
    ) -> TransferResult; fn invoke_contract_raw(
        &mut self,
        to: &ContractAddress,
        parameter: Parameter<'_>,
        method: EntrypointName<'_>,
        amount: Amount
    ) -> CallContractResult<Self::ReturnValueType>; fn invoke_contract_raw_read_only(
        &self,
        to: &ContractAddress,
        parameter: Parameter<'_>,
        method: EntrypointName<'_>,
        amount: Amount
    ) -> ReadOnlyCallContractResult<Self::ReturnValueType>; fn state(&self) -> &State; fn state_mut(&mut self) -> &mut State; fn commit_state(&mut self); fn state_builder(&mut self) -> &mut StateBuilder<Self::StateApiType>; fn state_and_builder(
        &mut self
    ) -> (&mut State, &mut StateBuilder<Self::StateApiType>); fn self_balance(&self) -> Amount; fn invoke_contract<P: Serial>(
        &mut self,
        to: &ContractAddress,
        parameter: &P,
        method: EntrypointName<'_>,
        amount: Amount
    ) -> CallContractResult<Self::ReturnValueType> { ... } fn invoke_contract_read_only<P: Serial>(
        &self,
        to: &ContractAddress,
        parameter: &P,
        method: EntrypointName<'_>,
        amount: Amount
    ) -> ReadOnlyCallContractResult<Self::ReturnValueType> { ... } }
Expand description

A type that can serve as the host, meaning that it supports interactions with the chain, such as querying balance of the contract, accessing its state, and invoking operations on other contracts and accounts.

The trait is parameterized by the State type. This is the type of the contract state that the particular contract operates on.

Required Associated Types

The type of low-level state that is associated with the host. This provides access to low-level state operations.

The type of return values this host provides. This is the raw return value. The intention is that it will be deserialized by the consumer, via the Read implementation.

The Debug requirement exists so that consumers of this trait may use methods like ExpectReport::expect_report.

Required Methods

Perform a transfer to the given account if the contract has sufficient balance.

Invoke a given method of a contract with the amount and parameter provided. If invocation succeeds then the return value is a pair of a boolean which indicates whether the state of the contract has changed or not, and a possible return value. The return value is present if and only if a V1 contract was invoked.

Invoke a given method of a contract with the amount and parameter provided. If invocation succeeds and the state of the contract instance is not modified then the return value is the return value of the contract that was invoked. The return value is present (i.e., not None) if and only if a V1 contract was invoked. If the invocation succeeds but the state of the contract is modified then this method will panic.

Warning: If the state of the contract was modified prior, i.e., if a mutable reference obtained via state_mut was used to modify the state then the state must be manually stored via the commit_state function, otherwise it will not be seen by the callee.

Get an immutable reference to the contract state.

Get a mutable reference to the contract state.

Make sure the contract state is fully written out, so that any changes that were done in-memory up to the point in contract execution are reflected in the actual contract state maintained by the node.

Get the state_builder for the contract state.

Get a mutable reference to both the state and the builder. This is required due to limitations of the Rust type system, since otherwise it is not possible to get the reference to the state and the state builder at the same time. Once some incarnation of “view types” is stable this will likely be possible to remove, and the types of state_builder and state_mut can be refined.

Get the contract’s own current balance. Upon entry to the entrypoint the balance that is returned is the sum of balance of the contract at the time of the invocation and the amount that is being transferred to the contract.

Provided Methods

Like invoke_contract_raw, except that the parameter is automatically serialized. If the parameter already implements AsRef<[u8]> or can be equivalently cheaply converted to a byte array, then invoke_contract_raw should be used, since it avoids intermediate allocations.

Like invoke_contract_raw, except that the parameter is automatically serialized. If the parameter already implements AsRef<[u8]> or can be equivalently cheaply converted to a byte array, then invoke_contract_raw should be used, since it avoids intermediate allocations.

Warning: If the state of the contract was modified prior, i.e., if a mutable reference obtained via state_mut was used to modify the state then the state must be manually stored via the commit_state function, otherwise it will not be seen by the callee.

Implementors