Struct cw_multi_test::App

pub struct App<Bank = BankKeeper, Api = MockApi, Storage = MockStorage, Custom = FailingModule<Empty, Empty, Empty>, Wasm = WasmKeeper<Empty, Empty>, Staking = StakeKeeper, Distr = DistributionKeeper, Ibc = IbcFailingModule, Gov = GovFailingModule, Stargate = StargateFailing> { /* private fields */ }

Blockchain application simulator

This structure is the main component of the real-life blockchain simulator.

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, IbcFailingModule, GovFailingModule, StargateFailing>, &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, StargateT: Stargate,

pub fn router( &self ) -> &Router<BankT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, StargateT>

Returns a shared reference to application’s router.

pub fn api(&self) -> &ApiT

Returns a shared reference to application’s API.

pub fn storage(&self) -> &StorageT

Returns a shared reference to application’s storage.

pub fn storage_mut(&mut self) -> &mut StorageT

Returns a mutable reference to application’s storage.

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

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

Initializes modules.

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,

Queries a module.

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

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

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

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

pub fn store_code_with_creator( &mut self, creator: Addr, code: Box<dyn Contract<CustomT::ExecT, CustomT::QueryT>> ) -> u64

Registers contract code (like store_code), but takes the address of the code creator as an additional argument.

pub fn store_code_with_id( &mut self, creator: Addr, code_id: u64, code: Box<dyn Contract<CustomT::ExecT, CustomT::QueryT>> ) -> AnyResult<u64>

Registers contract code (like store_code_with_creator), but takes the code identifier as an additional argument.

pub fn duplicate_code(&mut self, code_id: u64) -> AnyResult<u64>

Duplicates the contract code identified by code_id and returns the identifier of the newly created copy of the contract code.

Examples

use cosmwasm_std::Addr;
use cw_multi_test::App;

// contract implementation
mod echo {
  // contract entry points not shown here
  pub fn contract() -> Box<dyn Contract<Empty>> {
    // should return the contract
  }
}

let mut app = App::default();

// store a new contract, save the code id
let code_id = app.store_code(echo::contract());

// duplicate the existing contract, duplicated contract has different code id
assert_ne!(code_id, app.duplicate_code(code_id).unwrap());

// zero is an invalid identifier for contract code, returns an error
assert_eq!("code id: invalid", app.duplicate_code(0).unwrap_err().to_string());

// there is no contract code with identifier 100 stored yet, returns an error
assert_eq!("code id 100: no such code", app.duplicate_code(100).unwrap_err().to_string());

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

Returns ContractData for the contract with specified address.

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

Returns a raw state dump of all key-values held by a contract with specified address.

pub fn contract_storage<'a>( &'a self, contract_addr: &Addr ) -> Box<dyn Storage + 'a>

Returns read-only storage for a contract with specified address.

pub fn contract_storage_mut<'a>( &'a mut self, contract_addr: &Addr ) -> Box<dyn Storage + 'a>

Returns read-write storage for a contract with specified address.

pub fn prefixed_storage<'a>(&'a self, namespace: &[u8]) -> Box<dyn Storage + 'a>

Returns read-only prefixed storage with specified namespace.

pub fn prefixed_storage_mut<'a>( &'a mut self, namespace: &[u8] ) -> Box<dyn Storage + 'a>

Returns mutable prefixed storage with specified namespace.

pub fn prefixed_multilevel_storage<'a>( &'a self, namespaces: &[&[u8]] ) -> Box<dyn Storage + 'a>

Returns read-only prefixed, multilevel storage with specified namespaces.

pub fn prefixed_multilevel_storage_mut<'a>( &'a mut self, namespaces: &[&[u8]] ) -> Box<dyn Storage + 'a>

Returns mutable prefixed, multilevel storage with specified namespaces.

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: CustomMsg + 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,

pub fn set_block(&mut self, block: BlockInfo)

Sets the initial block properties.

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

Updates the current block applying the specified closure, usually next_block.

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, e.g. wrap().query_wasm_smart, query_all_balances, …

pub fn execute_multi( &mut 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>>( &mut 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(&mut 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<Bank: Clone, Api: Clone, Storage: Clone, Custom: Clone, Wasm: Clone, Staking: Clone, Distr: Clone, Ibc: Clone, Gov: Clone, Stargate: Clone> Clone for App<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov, Stargate>

fn clone( &self ) -> App<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov, Stargate>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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: CustomMsg + 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,

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

Processes (executes) an 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>>( &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 function around execute() with WasmMsg::Execute message, but in this case 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>

Migrates a contract. Sender must be registered admin. This is just a helper function around execute() with WasmMsg::Migrate message.

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

Sends tokens to specified recipient. This is just a helper function around execute() with BankMsg::Send message.

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: CustomMsg + 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,

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