Struct App 

pub struct App<Bank = BankKeeper, Api = MockApi, Storage = MockStorage, Custom = FailingModule<Empty, Empty, Empty>, Wasm = WasmKeeper<Empty, Empty>, Staking = StakeKeeper, Distr = DistributionKeeper, Ibc = FailingModule<IbcMsg, IbcQuery, Empty>, Gov = FailingModule<GovMsg, Empty, Empty>, Stargate = StargateKeeper<Empty, Empty>> {
    pub router: RefCell<Router<Bank, Custom, Wasm, Staking, Distr, Ibc, Gov, Stargate>>,
    /* private fields */
}

Router is a persisted state. You can query this. Execution generally happens on the RouterCache, which then can be atomically committed or rolled back. We offer .execute() as a wrapper around cache, execute, commit/rollback process.

Fields

router: RefCell<Router<Bank, Custom, Wasm, Staking, Distr, Ibc, Gov, Stargate>>

Implementations

impl App

pub fn new<F>(init_fn: F) -> Self

where F: FnOnce(&mut Router<BankKeeper, FailingModule<Empty, Empty, Empty>, WasmKeeper<Empty, Empty>, StakeKeeper, DistributionKeeper, FailingModule<IbcMsg, IbcQuery, Empty>, FailingModule<GovMsg, Empty, Empty>, StargateKeeper<Empty, Empty>>, &dyn Api, &mut dyn Storage),

Creates new default App implementation working with Empty custom messages.

impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, StargateT> App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, StargateT>

where WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>, BankT: Bank, ApiT: Api, StorageT: Storage, CustomT: Module, StakingT: Staking, DistrT: Distribution, IbcT: Ibc, GovT: Gov,

pub fn init_modules<F, T>(&self, init_fn: F) -> T

where F: FnOnce(&mut Router<BankT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, StargateT>, &dyn Api, &mut dyn Storage) -> T,

pub fn read_module<F, T>(&self, query_fn: F) -> T

where F: FnOnce(&Router<BankT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, StargateT>, &dyn Api, &dyn Storage) -> T,

impl<BankT, ApiT, StorageT, CustomT, StakingT, DistrT, IbcT, GovT, StargateT> App<BankT, ApiT, StorageT, CustomT, WasmKeeper<CustomT::ExecT, CustomT::QueryT>, StakingT, DistrT, IbcT, GovT, StargateT>

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

pub fn store_code( &self, code: Box<dyn Contract<CustomT::ExecT, CustomT::QueryT>>, ) -> u64

This registers contract code (like uploading wasm bytecode on a chain), so it can later be used to instantiate a contract.

pub fn contract_data(&self, address: &Addr) -> AnyResult<ContractData>

This allows to get ContractData for specific contract

pub fn dump_wasm_raw(&self, address: &Addr) -> Vec<Record>

This gets a raw state dump of all key-values held by a given contract

impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, StargateT> App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, StargateT>

where CustomT::ExecT: Debug + PartialEq + Clone + 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, StargateT: Stargate<CustomT::ExecT, CustomT::QueryT>,

pub fn set_block(&self, block: BlockInfo)

pub fn update_block<F: Fn(&mut BlockInfo)>(&self, action: F)

pub fn block_info(&self) -> BlockInfo

Returns a copy of the current block_info

pub fn wrap(&self) -> QuerierWrapper<'_, CustomT::QueryT>

Simple helper so we get access to all the QuerierWrapper helpers, eg. wrap().query_wasm_smart, query_all_balances, …

pub fn execute_multi( &self, sender: Addr, msgs: Vec<CosmosMsg<CustomT::ExecT>>, ) -> AnyResult<Vec<AppResponse>>

Runs multiple CosmosMsg in one atomic operation. This will create a cache before the execution, so no state changes are persisted if any of them return an error. But all writes are persisted on success.

pub fn wasm_sudo<T: Serialize, U: Into<Addr>>( &self, contract_addr: U, msg: &T, ) -> AnyResult<AppResponse>

Call a smart contract in “sudo” mode. 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.

pub fn sudo(&self, msg: SudoMsg) -> AnyResult<AppResponse>

Runs arbitrary SudoMsg. 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.

Trait Implementations

impl Default for App

fn default() -> Self

Returns the “default value” for a type.

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

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, StargateT: Stargate<CustomT::ExecT, CustomT::QueryT>,

fn execute( &self, sender: Addr, msg: CosmosMsg<CustomT::ExecT>, ) -> 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.

fn instantiate_contract<T: Serialize, U: Into<String>>( &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 execute_contract<T: Serialize + Debug>( &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>

impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, StargateT> Querier for App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, StargateT>

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, StargateT: Stargate<CustomT::ExecT, CustomT::QueryT>,

fn raw_query(&self, bin_request: &[u8]) -> QuerierResult

raw_query is all that must be implemented for the Querier. This allows us to pass through binary queries from one level to another without knowing the custom format, or we can decode it, with the knowledge of the allowed types. People using the querier probably want one of the simpler auto-generated helper methods