Struct cw_multi_test::AppBuilder

pub struct AppBuilder<Bank, Api, Storage, Custom, Wasm, Staking, Distr> { /* private fields */ }

Utility to build App in stages. If particular items wont be set, defaults would be used

Implementations

impl AppBuilder<BankKeeper, MockApi, MockStorage, FailingModule<Empty, Empty, Empty>, WasmKeeper<Empty, Empty>, FailingStaking, FailingDistribution>

pub fn new() -> Self

Creates builder with default components working with empty exec and query messages.

impl<ExecC, QueryC> AppBuilder<BankKeeper, MockApi, MockStorage, FailingModule<ExecC, QueryC, Empty>, WasmKeeper<ExecC, QueryC>, FailingStaking, FailingDistribution>where
    ExecC: Debug + Clone + PartialEq + JsonSchema + DeserializeOwned + 'static,
    QueryC: Debug + CustomQuery + DeserializeOwned + 'static,

pub fn new_custom() -> Self

Creates builder with default components designed to work with custom exec and query messages.

impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT> AppBuilder<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT>

pub fn with_wasm<C: Module, NewWasm: Wasm<C::ExecT, C::QueryT>>(
    self,
    wasm: NewWasm
) -> AppBuilder<BankT, ApiT, StorageT, CustomT, NewWasm, StakingT, DistrT>

Overwrites default wasm executor.

At this point it is needed that new wasm implements some Wasm trait, but it doesn’t need to be bound to Bank or Custom yet - as those may change. The cross-components validation is done on final building.

Also it is possible to completely abandon trait bounding here which would not be bad idea, however it might make the message on build creepy in many cases, so as for properly build App we always want Wasm to be Wasm, some checks are done early.

pub fn with_bank<NewBank: Bank>(
    self,
    bank: NewBank
) -> AppBuilder<NewBank, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT>

Overwrites default bank interface

pub fn with_api<NewApi: Api>(
    self,
    api: NewApi
) -> AppBuilder<BankT, NewApi, StorageT, CustomT, WasmT, StakingT, DistrT>

Overwrites default api interface

pub fn with_storage<NewStorage: Storage>(
    self,
    storage: NewStorage
) -> AppBuilder<BankT, ApiT, NewStorage, CustomT, WasmT, StakingT, DistrT>

Overwrites default storage interface

pub fn with_custom<NewCustom: Module>(
    self,
    custom: NewCustom
) -> AppBuilder<BankT, ApiT, StorageT, NewCustom, WasmT, StakingT, DistrT>

Overwrites default custom messages handler

At this point it is needed that new custom implements some Module trait, but it doesn’t need to be bound to ExecC or QueryC yet - as those may change. The cross-components validation is done on final building.

Also it is possible to completely abandon trait bounding here which would not be bad idea, however it might make the message on build creepy in many cases, so as for properly build App we always want Wasm to be Wasm, some checks are done early.

pub fn with_staking<NewStaking: Staking>(
    self,
    staking: NewStaking
) -> AppBuilder<BankT, ApiT, StorageT, CustomT, WasmT, NewStaking, DistrT>

Overwrites default bank interface

pub fn with_distribution<NewDistribution: Distribution>(
    self,
    distribution: NewDistribution
) -> AppBuilder<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, NewDistribution>

Overwrites default bank interface

pub fn with_block(self, block: BlockInfo) -> Self

Overwrites default initial block

pub fn build<F>(
    self,
    init_fn: F
) -> App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT>where
    BankT: Bank,
    ApiT: Api,
    StorageT: Storage,
    CustomT: Module,
    WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>,
    StakingT: Staking,
    DistrT: Distribution,
    F: FnOnce(&mut Router<BankT, CustomT, WasmT, StakingT, DistrT>, &dyn Api, &mut dyn Storage),

Builds final App. At this point all components type have to be properly related to each other. If there are some generics related compilation error make sure, that all components are properly relating to each other.

Trait Implementations

impl Default for AppBuilder<BankKeeper, MockApi, MockStorage, FailingModule<Empty, Empty, Empty>, WasmKeeper<Empty, Empty>, FailingStaking, FailingDistribution>

fn default() -> Self

Returns the “default value” for a type.