Trait Executor

pub trait Executor<C>
where
    C: Clone + Debug + PartialEq + JsonSchema + 'static,
{
    // Required method
    fn execute(
        &mut self,
        sender: Addr,
        msg: CosmosMsg<C>,
    ) -> AnyResult<AppResponse>;

    // Provided methods
    fn instantiate_contract<T: Serialize, U: Into<String>>(
        &mut self,
        code_id: u64,
        sender: Addr,
        init_msg: &T,
        send_funds: &[Coin],
        label: U,
        admin: Option<String>,
    ) -> AnyResult<Addr> { ... }
    fn instantiate2_contract<M, L, A, S>(
        &mut self,
        code_id: u64,
        sender: Addr,
        init_msg: &M,
        funds: &[Coin],
        label: L,
        admin: A,
        salt: S,
    ) -> AnyResult<Addr>
       where M: Serialize,
             L: Into<String>,
             A: Into<Option<String>>,
             S: Into<Binary> { ... }
    fn execute_contract<T: Serialize + Debug>(
        &mut self,
        sender: Addr,
        contract_addr: Addr,
        msg: &T,
        send_funds: &[Coin],
    ) -> AnyResult<AppResponse> { ... }
    fn migrate_contract<T: Serialize>(
        &mut self,
        sender: Addr,
        contract_addr: Addr,
        msg: &T,
        new_code_id: u64,
    ) -> AnyResult<AppResponse> { ... }
    fn send_tokens(
        &mut self,
        sender: Addr,
        recipient: Addr,
        amount: &[Coin],
    ) -> AnyResult<AppResponse> { ... }
}

Required Methods

fn execute(&mut self, sender: Addr, msg: CosmosMsg<C>) -> AnyResult<AppResponse>

Runs arbitrary CosmosMsg. This will create a cache before the execution, so no state changes are persisted if this returns an error, but all are persisted on success.

Provided Methods

fn instantiate_contract<T: Serialize, U: Into<String>>( &mut self, code_id: u64, sender: Addr, init_msg: &T, send_funds: &[Coin], label: U, admin: Option<String>, ) -> AnyResult<Addr>

Create a contract and get the new address. This is just a helper around execute()

fn instantiate2_contract<M, L, A, S>( &mut self, code_id: u64, sender: Addr, init_msg: &M, funds: &[Coin], label: L, admin: A, salt: S, ) -> AnyResult<Addr>

where M: Serialize, L: Into<String>, A: Into<Option<String>>, S: Into<Binary>,

Instantiates a new contract and returns its predictable address. This is a helper function around execute function with WasmMsg::Instantiate2 message.

fn execute_contract<T: Serialize + Debug>( &mut self, sender: Addr, contract_addr: Addr, msg: &T, send_funds: &[Coin], ) -> AnyResult<AppResponse>

Execute a contract and process all returned messages. This is just a helper around execute(), but we parse out the data field to that what is returned by the contract (not the protobuf wrapper)

fn migrate_contract<T: Serialize>( &mut self, sender: Addr, contract_addr: Addr, msg: &T, new_code_id: u64, ) -> AnyResult<AppResponse>

Migrate a contract. Sender must be registered admin. This is just a helper around execute()

fn send_tokens( &mut self, sender: Addr, recipient: Addr, amount: &[Coin], ) -> AnyResult<AppResponse>

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

impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT> Executor<<CustomT as Module>::ExecT> for App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>

where CustomT::ExecT: Clone + Debug + PartialEq + JsonSchema + DeserializeOwned + 'static, CustomT::QueryT: CustomQuery + DeserializeOwned + 'static, WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>, BankT: Bank, ApiT: Api, StorageT: Storage, CustomT: Module, StakingT: Staking, DistrT: Distribution, IbcT: Ibc, GovT: Gov,