Struct CyberApp

pub struct CyberApp(/* private fields */);

Implementations

impl CyberApp

pub fn new() -> Self

pub fn block_info(&self) -> BlockInfo

pub fn advance_blocks(&mut self, blocks: u64)

pub fn advance_seconds(&mut self, seconds: u64)

pub fn next_block(&mut self)

Methods from Deref<Target = CyberAppWrapped>

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,

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,

pub fn store_code( &mut self, code: Box<dyn Contract<<CustomT as Module>::ExecT, <CustomT as Module>::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 as Module>::ExecT, <CustomT as Module>::QueryT>>, ) -> u64

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

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

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) -> Result<ContractData, Error>

Returns ContractData for the contract with specified address.

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

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

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

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

where F: Fn(&mut BlockInfo),

pub fn block_info(&self) -> BlockInfo

Returns a copy of the current block_info

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

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

pub fn execute_multi( &mut self, sender: Addr, msgs: Vec<CosmosMsg<<CustomT as Module>::ExecT>>, ) -> Result<Vec<AppResponse>, Error>

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, U>( &mut self, contract_addr: U, msg: &T, ) -> Result<AppResponse, Error>

where T: Serialize, U: Into<Addr>,

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) -> Result<AppResponse, Error>

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 CyberApp

fn default() -> Self

Returns the “default value” for a type.

impl Deref for CyberApp

type Target = App<BankKeeper, MockApi, MemoryStorage, CyberModule, WasmKeeper<CyberMsg, CyberQuery>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for CyberApp

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Querier for CyberApp

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