diff --git a/packages/multi-test/Cargo.toml b/packages/multi-test/Cargo.toml
index 4735c49e0..812173f24 100644
--- a/packages/multi-test/Cargo.toml
+++ b/packages/multi-test/Cargo.toml
@@ -11,9 +11,10 @@ documentation = "https://docs.cosmwasm.com"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [features]
-default = ["iterator"]
+default = ["iterator", "staking"]
 iterator = ["cosmwasm-std/iterator"]
 stargate = ["cosmwasm-std/stargate"]
+staking = ["cosmwasm-std/staking"]
 backtrace = ["anyhow/backtrace"]
 
 [dependencies]
diff --git a/packages/multi-test/src/app.rs b/packages/multi-test/src/app.rs
index 93fb30ba2..c57a04bee 100644
--- a/packages/multi-test/src/app.rs
+++ b/packages/multi-test/src/app.rs
@@ -2,9 +2,8 @@ use std::fmt::{self, Debug};
 
 use cosmwasm_std::testing::{mock_env, MockApi, MockStorage};
 use cosmwasm_std::{
-    from_slice, to_vec, Addr, Api, Binary, BlockInfo, Coin, ContractResult, CosmosMsg, CustomQuery,
-    Empty, Querier, QuerierResult, QuerierWrapper, QueryRequest, Storage, SystemError,
-    SystemResult,
+    from_slice, to_vec, Addr, Api, Binary, BlockInfo, Coin, ContractResult, CustomQuery, Empty,
+    Querier, QuerierResult, QuerierWrapper, QueryRequest, Storage, SystemError, SystemResult,
 };
 use schemars::JsonSchema;
 use serde::de::DeserializeOwned;
@@ -15,6 +14,7 @@ use crate::contracts::Contract;
 use crate::custom_handler::{CustomHandler, PanickingCustomHandler};
 use crate::executor::{AppResponse, Executor};
 use crate::transactions::transactional;
+use crate::untyped_msg::CosmosMsg;
 use crate::wasm::{ContractData, Wasm, WasmKeeper};
 use crate::BankKeeper;
 
@@ -101,7 +101,11 @@ where
     StorageT: Storage,
     CustomT: CustomHandler,
 {
-    fn execute(&mut self, sender: Addr, msg: CosmosMsg<CustomT::ExecC>) -> AnyResult<AppResponse> {
+    fn execute(
+        &mut self,
+        sender: Addr,
+        msg: cosmwasm_std::CosmosMsg<CustomT::ExecC>,
+    ) -> AnyResult<AppResponse> {
         let mut all = self.execute_multi(sender, vec![msg])?;
         let res = all.pop().unwrap();
         Ok(res)
@@ -385,7 +389,7 @@ where
     pub fn execute_multi(
         &mut self,
         sender: Addr,
-        msgs: Vec<CosmosMsg<CustomT::ExecC>>,
+        msgs: Vec<cosmwasm_std::CosmosMsg<CustomT::ExecC>>,
     ) -> AnyResult<Vec<AppResponse>> {
         // we need to do some caching of storage here, once in the entry point:
         // meaning, wrap current state, all writes go to a cache, only when execute
@@ -400,7 +404,7 @@ where
 
         transactional(&mut *storage, |write_cache, _| {
             msgs.into_iter()
-                .map(|msg| router.execute(&*api, write_cache, block, sender.clone(), msg))
+                .map(|msg| router.execute(&*api, write_cache, block, sender.clone(), msg.into()))
                 .collect()
         })
     }
@@ -449,13 +453,20 @@ pub struct Router<Bank, Custom, Wasm> {
     pub(crate) custom: Custom,
 }
 
-impl<BankT, CustomT, WasmT> Router<BankT, CustomT, WasmT> {
+impl<BankT, CustomT, WasmT> Router<BankT, CustomT, WasmT>
+where
+    CustomT::ExecC: Clone + fmt::Debug + PartialEq + JsonSchema + DeserializeOwned + 'static,
+    CustomT::QueryC: CustomQuery + DeserializeOwned + 'static,
+    CustomT: CustomHandler,
+    WasmT: Wasm<CustomT::ExecC, CustomT::QueryC>,
+    BankT: Bank,
+{
     pub fn querier<'a>(
         &'a self,
         api: &'a dyn Api,
         storage: &'a dyn Storage,
         block_info: &'a BlockInfo,
-    ) -> RouterQuerier<'a, BankT, CustomT, WasmT> {
+    ) -> RouterQuerier<'a, CustomT::ExecC, CustomT::QueryC> {
         RouterQuerier {
             router: self,
             api,
@@ -463,25 +474,67 @@ impl<BankT, CustomT, WasmT> Router<BankT, CustomT, WasmT> {
             block_info,
         }
     }
+}
+
+pub trait CosmosRouter {
+    type ExecC;
+    type QueryC: CustomQuery;
+
+    fn execute(
+        &self,
+        api: &dyn Api,
+        storage: &mut dyn Storage,
+        block: &BlockInfo,
+        sender: Addr,
+        msg: CosmosMsg<Self::ExecC>,
+    ) -> AnyResult<AppResponse>;
+
+    fn query(
+        &self,
+        api: &dyn Api,
+        storage: &dyn Storage,
+        block: &BlockInfo,
+        request: QueryRequest<Self::QueryC>,
+    ) -> AnyResult<Binary>;
+}
+
+impl<BankT, CustomT, WasmT> CosmosRouter for Router<BankT, CustomT, WasmT>
+where
+    CustomT::ExecC: std::fmt::Debug + Clone + PartialEq + JsonSchema + DeserializeOwned + 'static,
+    CustomT::QueryC: CustomQuery + DeserializeOwned + 'static,
+    CustomT: CustomHandler,
+    WasmT: Wasm<CustomT::ExecC, CustomT::QueryC>,
+    BankT: Bank,
+{
+    type ExecC = CustomT::ExecC;
+    type QueryC = CustomT::QueryC;
+
+    fn execute(
+        &self,
+        api: &dyn Api,
+        storage: &mut dyn Storage,
+        block: &BlockInfo,
+        sender: Addr,
+        msg: CosmosMsg<Self::ExecC>,
+    ) -> AnyResult<AppResponse> {
+        match msg {
+            CosmosMsg::Wasm(msg) => self.wasm.execute(api, storage, self, block, sender, msg),
+            CosmosMsg::Bank(msg) => self.bank.execute(storage, sender, msg),
+            CosmosMsg::Custom(msg) => self.custom.execute(api, storage, block, sender, msg),
+            _ => unimplemented!(),
+        }
+    }
 
     /// this is used by `RouterQuerier` to actual implement the `Querier` interface.
     /// you most likely want to use `router.querier(storage, block).wrap()` to get a
     /// QuerierWrapper to interact with
-    pub fn query(
+    fn query(
         &self,
         api: &dyn Api,
         storage: &dyn Storage,
         block: &BlockInfo,
-        request: QueryRequest<CustomT::QueryC>,
-    ) -> AnyResult<Binary>
-    where
-        CustomT::QueryC: CustomQuery + DeserializeOwned + 'static,
-        CustomT::ExecC:
-            std::fmt::Debug + PartialEq + Clone + JsonSchema + DeserializeOwned + 'static,
-        WasmT: Wasm<CustomT::ExecC, CustomT::QueryC>,
-        BankT: Bank,
-        CustomT: CustomHandler,
-    {
+        request: QueryRequest<Self::QueryC>,
+    ) -> AnyResult<Binary> {
         match request {
             QueryRequest::Wasm(req) => {
                 self.wasm
@@ -492,40 +545,18 @@ impl<BankT, CustomT, WasmT> Router<BankT, CustomT, WasmT> {
             _ => unimplemented!(),
         }
     }
-
-    pub fn execute(
-        &self,
-        api: &dyn Api,
-        storage: &mut dyn Storage,
-        block: &BlockInfo,
-        sender: Addr,
-        msg: CosmosMsg<CustomT::ExecC>,
-    ) -> AnyResult<AppResponse>
-    where
-        CustomT::ExecC: std::fmt::Debug + Clone + PartialEq + JsonSchema,
-        WasmT: Wasm<CustomT::ExecC, CustomT::QueryC>,
-        BankT: Bank,
-        CustomT: CustomHandler,
-    {
-        match msg {
-            CosmosMsg::Wasm(msg) => self.wasm.execute(api, storage, &self, block, sender, msg),
-            CosmosMsg::Bank(msg) => self.bank.execute(storage, sender, msg),
-            CosmosMsg::Custom(msg) => self.custom.execute(api, storage, block, sender, msg),
-            _ => unimplemented!(),
-        }
-    }
 }
 
-pub struct RouterQuerier<'a, Bank, Custom, Wasm> {
-    router: &'a Router<Bank, Custom, Wasm>,
+pub struct RouterQuerier<'a, ExecC, QueryC> {
+    router: &'a dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
     api: &'a dyn Api,
     storage: &'a dyn Storage,
     block_info: &'a BlockInfo,
 }
 
-impl<'a, Bank, Custom, Wasm> RouterQuerier<'a, Bank, Custom, Wasm> {
+impl<'a, ExecC, QueryC> RouterQuerier<'a, ExecC, QueryC> {
     pub fn new(
-        router: &'a Router<Bank, Custom, Wasm>,
+        router: &'a dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         api: &'a dyn Api,
         storage: &'a dyn Storage,
         block_info: &'a BlockInfo,
@@ -539,16 +570,13 @@ impl<'a, Bank, Custom, Wasm> RouterQuerier<'a, Bank, Custom, Wasm> {
     }
 }
 
-impl<'a, BankT, CustomT, WasmT> Querier for RouterQuerier<'a, BankT, CustomT, WasmT>
+impl<'a, ExecC, QueryC> Querier for RouterQuerier<'a, ExecC, QueryC>
 where
-    CustomT::ExecC: Clone + fmt::Debug + PartialEq + JsonSchema + DeserializeOwned + 'static,
-    CustomT::QueryC: CustomQuery + DeserializeOwned + 'static,
-    WasmT: Wasm<CustomT::ExecC, CustomT::QueryC>,
-    BankT: Bank,
-    CustomT: CustomHandler,
+    ExecC: Clone + fmt::Debug + PartialEq + JsonSchema + DeserializeOwned + 'static,
+    QueryC: CustomQuery + DeserializeOwned + 'static,
 {
     fn raw_query(&self, bin_request: &[u8]) -> QuerierResult {
-        let request: QueryRequest<CustomT::QueryC> = match from_slice(bin_request) {
+        let request: QueryRequest<QueryC> = match from_slice(bin_request) {
             Ok(v) => v,
             Err(e) => {
                 return SystemResult::Err(SystemError::InvalidRequest {
@@ -622,7 +650,7 @@ mod test {
 
         // send both tokens
         let to_send = vec![coin(30, "eth"), coin(5, "btc")];
-        let msg: CosmosMsg = BankMsg::Send {
+        let msg: cosmwasm_std::CosmosMsg = BankMsg::Send {
             to_address: rcpt.clone().into(),
             amount: to_send,
         }
diff --git a/packages/multi-test/src/lib.rs b/packages/multi-test/src/lib.rs
index 1c1e0fec4..c04ae504d 100644
--- a/packages/multi-test/src/lib.rs
+++ b/packages/multi-test/src/lib.rs
@@ -14,6 +14,7 @@ pub mod error;
 mod executor;
 mod test_helpers;
 mod transactions;
+mod untyped_msg;
 mod wasm;
 
 pub use crate::app::{custom_app, next_block, App, AppBuilder, BasicApp, Router};
diff --git a/packages/multi-test/src/untyped_msg.rs b/packages/multi-test/src/untyped_msg.rs
new file mode 100644
index 000000000..9e857fdcb
--- /dev/null
+++ b/packages/multi-test/src/untyped_msg.rs
@@ -0,0 +1,95 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+use cosmwasm_std::{BankMsg, DistributionMsg, Empty, StakingMsg, WasmMsg};
+
+/// This is needed so we can embed CosmosMsg as a trait bound.
+/// See https://github.com/CosmWasm/cosmwasm/pull/1098 for a proper solution
+/// (when we can deprecate this one)
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum CosmosMsg<T = Empty> {
+    Bank(BankMsg),
+    // by default we use RawMsg, but a contract can override that
+    // to call into more app-specific code (whatever they define)
+    Custom(T),
+    #[cfg(feature = "staking")]
+    Distribution(DistributionMsg),
+    #[cfg(feature = "staking")]
+    Staking(StakingMsg),
+    Wasm(WasmMsg),
+}
+
+impl<T> From<CosmosMsg<T>> for cosmwasm_std::CosmosMsg<T>
+where
+    T: Clone + fmt::Debug + PartialEq + JsonSchema,
+{
+    fn from(input: CosmosMsg<T>) -> Self {
+        match input {
+            CosmosMsg::Bank(b) => cosmwasm_std::CosmosMsg::Bank(b),
+            CosmosMsg::Custom(c) => cosmwasm_std::CosmosMsg::Custom(c),
+            #[cfg(feature = "staking")]
+            CosmosMsg::Distribution(d) => cosmwasm_std::CosmosMsg::Distribution(d),
+            #[cfg(feature = "staking")]
+            CosmosMsg::Staking(s) => cosmwasm_std::CosmosMsg::Staking(s),
+            CosmosMsg::Wasm(w) => cosmwasm_std::CosmosMsg::Wasm(w),
+        }
+    }
+}
+
+impl<T> From<cosmwasm_std::CosmosMsg<T>> for CosmosMsg<T>
+where
+    T: Clone + fmt::Debug + PartialEq + JsonSchema,
+{
+    fn from(input: cosmwasm_std::CosmosMsg<T>) -> CosmosMsg<T> {
+        match input {
+            cosmwasm_std::CosmosMsg::Bank(b) => CosmosMsg::Bank(b),
+            cosmwasm_std::CosmosMsg::Custom(c) => CosmosMsg::Custom(c),
+            #[cfg(feature = "staking")]
+            cosmwasm_std::CosmosMsg::Distribution(d) => CosmosMsg::Distribution(d),
+            #[cfg(feature = "staking")]
+            cosmwasm_std::CosmosMsg::Staking(s) => CosmosMsg::Staking(s),
+            cosmwasm_std::CosmosMsg::Wasm(w) => CosmosMsg::Wasm(w),
+            _ => panic!("Unsupported type"),
+        }
+    }
+}
+
+impl<T> From<BankMsg> for CosmosMsg<T>
+where
+    T: Clone + fmt::Debug + PartialEq + JsonSchema,
+{
+    fn from(msg: BankMsg) -> Self {
+        CosmosMsg::Bank(msg)
+    }
+}
+
+#[cfg(feature = "staking")]
+impl<T> From<StakingMsg> for CosmosMsg<T>
+where
+    T: Clone + fmt::Debug + PartialEq + JsonSchema,
+{
+    fn from(msg: StakingMsg) -> Self {
+        CosmosMsg::Staking(msg)
+    }
+}
+
+#[cfg(feature = "staking")]
+impl<T> From<DistributionMsg> for CosmosMsg<T>
+where
+    T: Clone + fmt::Debug + PartialEq + JsonSchema,
+{
+    fn from(msg: DistributionMsg) -> Self {
+        CosmosMsg::Distribution(msg)
+    }
+}
+
+impl<T> From<WasmMsg> for CosmosMsg<T>
+where
+    T: Clone + fmt::Debug + PartialEq + JsonSchema,
+{
+    fn from(msg: WasmMsg) -> Self {
+        CosmosMsg::Wasm(msg)
+    }
+}
diff --git a/packages/multi-test/src/wasm.rs b/packages/multi-test/src/wasm.rs
index a1c4f7cf3..7219e9357 100644
--- a/packages/multi-test/src/wasm.rs
+++ b/packages/multi-test/src/wasm.rs
@@ -15,12 +15,11 @@ use serde::{Deserialize, Serialize};
 
 use cw_storage_plus::Map;
 
-use crate::app::{Router, RouterQuerier};
+use crate::app::{CosmosRouter, RouterQuerier};
 use crate::contracts::Contract;
 use crate::error::Error;
 use crate::executor::AppResponse;
 use crate::transactions::transactional;
-use crate::{Bank, CustomHandler};
 use cosmwasm_std::testing::mock_wasmd_attr;
 
 use anyhow::{anyhow, bail, Result as AnyResult};
@@ -59,19 +58,15 @@ pub trait Wasm<ExecC, QueryC> {
     ) -> AnyResult<Binary>;
 
     /// Handles all WasmMsg messages
-    fn execute<BankT, CustomT>(
+    fn execute(
         &self,
         api: &dyn Api,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         sender: Addr,
         msg: WasmMsg,
-    ) -> AnyResult<AppResponse>
-    where
-        Self: Sized,
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>;
+    ) -> AnyResult<AppResponse>;
 
     // Add a new contract. Must be done on the base object, when no contracts running
     fn store_code(&mut self, code: Box<dyn Contract<ExecC>>) -> usize;
@@ -80,19 +75,15 @@ pub trait Wasm<ExecC, QueryC> {
     fn contract_data(&self, storage: &dyn Storage, address: &Addr) -> AnyResult<ContractData>;
 
     /// Admin interface, cannot be called via CosmosMsg
-    fn sudo<BankT, CustomT>(
+    fn sudo(
         &self,
         api: &dyn Api,
         contract_addr: Addr,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         msg: Vec<u8>,
-    ) -> AnyResult<AppResponse>
-    where
-        Self: Sized,
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>;
+    ) -> AnyResult<AppResponse>;
 }
 
 pub struct WasmKeeper<ExecC, QueryC> {
@@ -138,19 +129,15 @@ where
         }
     }
 
-    fn execute<BankT, CustomT>(
+    fn execute(
         &self,
         api: &dyn Api,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         sender: Addr,
         msg: WasmMsg,
-    ) -> AnyResult<AppResponse>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<AppResponse> {
         let (resender, res, custom_event) =
             self.execute_wasm(api, storage, router, block, sender, msg)?;
 
@@ -168,19 +155,15 @@ where
         self.load_contract(storage, address)
     }
 
-    fn sudo<BankT, CustomT>(
+    fn sudo(
         &self,
         api: &dyn Api,
         contract: Addr,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         msg: Vec<u8>,
-    ) -> AnyResult<AppResponse>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<AppResponse> {
         let custom_event = Event::new("sudo").add_attribute(CONTRACT_ATTR, &contract);
 
         let res = self.call_sudo(contract.clone(), api, storage, router, block, msg)?;
@@ -223,11 +206,11 @@ where
         data.into()
     }
 
-    fn send<T, BankT, CustomT>(
+    fn send<T>(
         &self,
         api: &dyn Api,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         sender: T,
         recipient: String,
@@ -235,14 +218,13 @@ where
     ) -> AnyResult<AppResponse>
     where
         T: Into<Addr>,
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
     {
         if !amount.is_empty() {
-            let msg = BankMsg::Send {
+            let msg: cosmwasm_std::CosmosMsg<ExecC> = BankMsg::Send {
                 to_address: recipient,
                 amount: amount.to_vec(),
-            };
+            }
+            .into();
             let res = router.execute(api, storage, block, sender.into(), msg.into())?;
             Ok(res)
         } else {
@@ -251,19 +233,15 @@ where
     }
 
     // this returns the contract address as well, so we can properly resend the data
-    fn execute_wasm<BankT, CustomT>(
+    fn execute_wasm(
         &self,
         api: &dyn Api,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         sender: Addr,
         wasm_msg: WasmMsg,
-    ) -> AnyResult<(Addr, Response<ExecC>, Event)>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<(Addr, Response<ExecC>, Event)> {
         match wasm_msg {
             WasmMsg::Execute {
                 contract_addr,
@@ -394,26 +372,22 @@ where
     ///
     /// The `data` on `AppResponse` is data returned from `reply` call, not from execution of
     /// submessage itself. In case if `reply` is not called, no `data` is set.
-    fn execute_submsg<BankT, CustomT>(
+    fn execute_submsg(
         &self,
         api: &dyn Api,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         storage: &mut dyn Storage,
         block: &BlockInfo,
         contract: Addr,
         msg: SubMsg<ExecC>,
-    ) -> AnyResult<AppResponse>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<AppResponse> {
         let SubMsg {
             msg, id, reply_on, ..
         } = msg;
 
         // execute in cache
         let res = transactional(storage, |write_cache, _| {
-            router.execute(api, write_cache, block, contract.clone(), msg)
+            router.execute(api, write_cache, block, contract.clone(), msg.into())
         });
 
         // call reply if meaningful
@@ -453,19 +427,15 @@ where
         }
     }
 
-    fn _reply<BankT, CustomT>(
+    fn _reply(
         &self,
         api: &dyn Api,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         storage: &mut dyn Storage,
         block: &BlockInfo,
         contract: Addr,
         reply: Reply,
-    ) -> AnyResult<AppResponse>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<AppResponse> {
         let ok_attr = if reply.result.is_ok() {
             "handle_success"
         } else {
@@ -526,20 +496,16 @@ where
         (app, messages)
     }
 
-    fn process_response<BankT, CustomT>(
+    fn process_response(
         &self,
         api: &dyn Api,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         storage: &mut dyn Storage,
         block: &BlockInfo,
         contract: Addr,
         response: AppResponse,
         messages: Vec<SubMsg<ExecC>>,
-    ) -> AnyResult<AppResponse>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<AppResponse> {
         let AppResponse { mut events, data } = response;
 
         // recurse in all messages
@@ -582,20 +548,16 @@ where
         Ok(addr)
     }
 
-    pub fn call_execute<BankT, CustomT>(
+    pub fn call_execute(
         &self,
         api: &dyn Api,
         storage: &mut dyn Storage,
         address: Addr,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         info: MessageInfo,
         msg: Vec<u8>,
-    ) -> AnyResult<Response<ExecC>>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<Response<ExecC>> {
         Self::verify_response(self.with_storage(
             api,
             storage,
@@ -606,20 +568,16 @@ where
         )?)
     }
 
-    pub fn call_instantiate<BankT, CustomT>(
+    pub fn call_instantiate(
         &self,
         address: Addr,
         api: &dyn Api,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         info: MessageInfo,
         msg: Vec<u8>,
-    ) -> AnyResult<Response<ExecC>>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<Response<ExecC>> {
         Self::verify_response(self.with_storage(
             api,
             storage,
@@ -630,19 +588,15 @@ where
         )?)
     }
 
-    pub fn call_reply<BankT, CustomT>(
+    pub fn call_reply(
         &self,
         address: Addr,
         api: &dyn Api,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         reply: Reply,
-    ) -> AnyResult<Response<ExecC>>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<Response<ExecC>> {
         Self::verify_response(self.with_storage(
             api,
             storage,
@@ -653,19 +607,15 @@ where
         )?)
     }
 
-    pub fn call_sudo<BankT, CustomT>(
+    pub fn call_sudo(
         &self,
         address: Addr,
         api: &dyn Api,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         msg: Vec<u8>,
-    ) -> AnyResult<Response<ExecC>>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<Response<ExecC>> {
         Self::verify_response(self.with_storage(
             api,
             storage,
@@ -676,19 +626,15 @@ where
         )?)
     }
 
-    pub fn call_migrate<BankT, CustomT>(
+    pub fn call_migrate(
         &self,
         address: Addr,
         api: &dyn Api,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         msg: Vec<u8>,
-    ) -> AnyResult<Response<ExecC>>
-    where
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
-    {
+    ) -> AnyResult<Response<ExecC>> {
         Self::verify_response(self.with_storage(
             api,
             storage,
@@ -736,21 +682,18 @@ where
         action(handler, deps, env)
     }
 
-    fn with_storage<F, T, BankT, CustomT>(
+    fn with_storage<F, T>(
         &self,
         api: &dyn Api,
         storage: &mut dyn Storage,
-        router: &Router<BankT, CustomT, Self>,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
         block: &BlockInfo,
         address: Addr,
         action: F,
     ) -> AnyResult<T>
     where
         F: FnOnce(&Box<dyn Contract<ExecC>>, DepsMut, Env) -> AnyResult<T>,
-        BankT: Bank,
-        CustomT: CustomHandler<ExecC = ExecC, QueryC = QueryC>,
         ExecC: DeserializeOwned,
-        QueryC: 'static,
     {
         let contract = self.load_contract(storage, &address)?;
         let handler = self
@@ -917,6 +860,7 @@ mod test {
     use cosmwasm_std::testing::{mock_env, mock_info, MockApi, MockQuerier, MockStorage};
     use cosmwasm_std::{coin, from_slice, to_vec, BankMsg, Coin, CosmosMsg, Empty, StdError};
 
+    use crate::app::Router;
     use crate::test_helpers::contracts::{error, payout};
     use crate::transactions::StorageTransaction;
     use crate::BankKeeper;