Generalized querier getter

cw-orch-daemon/src/queriers.rs

@@ -47,18 +47,19 @@ macro_rules! cosmos_query {
 mod authz;
 mod bank;
 mod cosmwasm;
+mod env;
 mod feegrant;
 mod gov;
 mod ibc;
 mod node;
 mod staking;
 
 pub use authz::Authz;
-pub use bank::{cosmrs_to_cosmwasm_coins, Bank};
-pub use cosmwasm::CosmWasm;
+pub use bank::{cosmrs_to_cosmwasm_coins, Bank, DaemonBankQuerier};
+pub use cosmwasm::{CosmWasm, DaemonWasmQuerier};
 pub use feegrant::Feegrant;
 pub use ibc::Ibc;
-pub use node::Node;
+pub use node::{DaemonNodeQuerier, Node};
 
 // this two containt structs that are helpers for the queries
 pub use gov::*;

cw-orch-daemon/src/queriers/bank.rs

@@ -1,7 +1,7 @@
 use crate::{cosmos_modules, error::DaemonError, Daemon};
 use cosmrs::proto::cosmos::base::{query::v1beta1::PageRequest, v1beta1::Coin};
 use cosmwasm_std::StdError;
-use cw_orch_core::environment::queriers::bank::{BankQuerier, BankQuerierGetter};
+use cw_orch_core::environment::{BankQuerier, Querier, QuerierGetter};
 use tokio::runtime::Handle;
 use tonic::transport::Channel;
 
@@ -157,17 +157,17 @@
     }
 }
 
-impl BankQuerierGetter<DaemonError> for Daemon {
-    type Querier = DaemonBankQuerier;
+impl Querier for DaemonBankQuerier {
+    type Error = DaemonError;
+}
 
-    fn bank_querier(&self) -> Self::Querier {
+impl QuerierGetter<DaemonBankQuerier> for Daemon {
+    fn querier(&self) -> DaemonBankQuerier {
         DaemonBankQuerier::new(self)
     }
 }
 
 impl BankQuerier for DaemonBankQuerier {
-    type Error = DaemonError;
-
     fn balance(
         &self,
         address: impl Into<String>,
@@ -183,21 +183,21 @@
             })??)
     }
 
     fn total_supply(&self) -> Result<Vec<cosmwasm_std::Coin>, Self::Error> {
         Ok(self
             .rt_handle
             .block_on(Bank::new(self.channel.clone()).total_supply())
             .map(|c| {
                 c.into_iter()
                     .map(cosmrs_to_cosmwasm_coins)
                     .collect::<Result<Vec<_>, StdError>>()
             })??)
     }
 
     fn supply_of(&self, denom: impl Into<String>) -> Result<cosmwasm_std::Coin, Self::Error> {
         Ok(self
             .rt_handle
             .block_on(Bank::new(self.channel.clone()).supply_of(denom))
             .map(cosmrs_to_cosmwasm_coins)??)
     }
 }

cw-orch-daemon/src/queriers/cosmwasm.rs

@@ -1,7 +1,7 @@
 use crate::{cosmos_modules, error::DaemonError, Daemon};
 use cosmrs::proto::cosmos::base::query::v1beta1::PageRequest;
 use cosmwasm_std::{from_json, to_json_binary, CodeInfoResponse, ContractInfoResponse};
-use cw_orch_core::environment::queriers::wasm::{WasmQuerier, WasmQuerierGetter};
+use cw_orch_core::environment::{Querier, QuerierGetter, WasmQuerier};
 use tokio::runtime::Handle;
 use tonic::transport::Channel;
 
@@ -187,17 +187,17 @@
     }
 }
 
-impl WasmQuerierGetter<DaemonError> for Daemon {
-    type Querier = DaemonWasmQuerier;
-
-    fn wasm_querier(&self) -> Self::Querier {
+impl QuerierGetter<DaemonWasmQuerier> for Daemon {
+    fn querier(&self) -> DaemonWasmQuerier {
         DaemonWasmQuerier::new(self)
     }
 }
 
-impl WasmQuerier for DaemonWasmQuerier {
+impl Querier for DaemonWasmQuerier {
     type Error = DaemonError;
+}
 
+impl WasmQuerier for DaemonWasmQuerier {
     fn code_id_hash(&self, code_id: u64) -> Result<String, Self::Error> {
         self.rt_handle
             .block_on(CosmWasm::new(self.channel.clone()).code_id_hash(code_id))
@@ -215,32 +215,32 @@
         c.code_id = contract_info.code_id;
         c.creator = contract_info.creator;
         c.admin = if contract_info.admin.is_empty() {
             None
         } else {
             Some(contract_info.admin)
         };
         c.ibc_port = if contract_info.ibc_port_id.is_empty() {
             None
         } else {
             Some(contract_info.ibc_port_id)
         };
 
         Ok(c)
     }
 
-    fn contract_raw_state(
+    fn raw_query(
         &self,
         address: impl Into<String>,
         query_data: Vec<u8>,
     ) -> Result<Vec<u8>, Self::Error> {
         let response = self.rt_handle.block_on(
             CosmWasm::new(self.channel.clone()).contract_raw_state(address, query_data),
         )?;
 
         Ok(response.data)
     }
 
-    fn contract_smart_state<Q: serde::Serialize, T: serde::de::DeserializeOwned>(
+    fn smart_query<Q: serde::Serialize, T: serde::de::DeserializeOwned>(
         &self,
         address: impl Into<String>,
         query_data: &Q,
@@ -248,21 +248,21 @@
         let response = self.rt_handle.block_on(
             CosmWasm::new(self.channel.clone())
                 .contract_state(address, to_json_binary(&query_data)?.to_vec()),
         )?;
 
         Ok(from_json(response)?)
     }
 
     fn code(&self, code_id: u64) -> Result<cosmwasm_std::CodeInfoResponse, Self::Error> {
         let response = self
             .rt_handle
             .block_on(CosmWasm::new(self.channel.clone()).code(code_id))?;
 
         let mut c = CodeInfoResponse::default();
         c.code_id = code_id;
         c.creator = response.creator;
         c.checksum = response.data_hash.into();
 
         Ok(c)
     }
 }

cw-orch-daemon/src/queriers/env.rs

@@ -0,0 +1,14 @@
+use cw_orch_core::environment::{EnvironmentInfo, EnvironmentQuerier};
+
+use crate::Daemon;
+
+impl EnvironmentQuerier for Daemon {
+    fn env_info(&self) -> EnvironmentInfo {
+        let state = &self.daemon.sender.daemon_state;
+        EnvironmentInfo {
+            chain_id: state.chain_data.chain_id.to_string(),
+            chain_name: state.chain_data.chain_name.clone(),
+            deployment_id: state.deployment_id.clone(),
+        }
+    }
+}

cw-orch-daemon/src/queriers/node.rs

@@ -11,7 +11,7 @@
 };
 use cosmwasm_std::BlockInfo;
 use cw_orch_core::{
-    environment::queriers::node::{NodeQuerier, NodeQuerierGetter},
+    environment::{NodeQuerier, Querier, QuerierGetter},
     log::query_target,
     CwOrchEnvVars,
 };
@@ -346,17 +346,17 @@
     }
 }
 
-impl NodeQuerierGetter<DaemonError> for Daemon {
-    type Querier = DaemonNodeQuerier;
-
-    fn node_querier(&self) -> Self::Querier {
+impl QuerierGetter<DaemonNodeQuerier> for Daemon {
+    fn querier(&self) -> DaemonNodeQuerier {
         DaemonNodeQuerier::new(self)
     }
 }
 
-impl NodeQuerier for DaemonNodeQuerier {
+impl Querier for DaemonNodeQuerier {
     type Error = DaemonError;
+}
 
+impl NodeQuerier for DaemonNodeQuerier {
     type Response = CosmTxResponse;
 
     fn latest_block(&self) -> Result<cosmwasm_std::BlockInfo, Self::Error> {
@@ -364,33 +364,33 @@
             .block_on(Node::new(self.channel.clone()).block_info())
     }
 
     fn block_by_height(&self, height: u64) -> Result<cosmwasm_std::BlockInfo, Self::Error> {
         let block = self
             .rt_handle
             .block_on(Node::new(self.channel.clone()).block_by_height(height))?;
 
         block_to_block_info(block)
     }
 
     fn block_height(&self) -> Result<u64, Self::Error> {
         self.rt_handle
             .block_on(Node::new(self.channel.clone()).block_height())
     }
 
     fn block_time(&self) -> Result<u128, Self::Error> {
         self.rt_handle
             .block_on(Node::new(self.channel.clone()).block_time())
     }
 
     fn simulate_tx(&self, tx_bytes: Vec<u8>) -> Result<u64, Self::Error> {
         self.rt_handle
             .block_on(Node::new(self.channel.clone()).simulate_tx(tx_bytes))
     }
 
     fn find_tx(&self, hash: String) -> Result<Self::Response, Self::Error> {
         self.rt_handle
             .block_on(Node::new(self.channel.clone()).find_tx(hash))
     }
 }
 
 fn block_to_block_info(block: Block) -> Result<BlockInfo, DaemonError> {

cw-orch-daemon/src/sync/core.rs

@@ -2,17 +2,14 @@ use std::{fmt::Debug, sync::Arc, time::Duration};
 
 use super::super::{sender::Wallet, DaemonAsync};
 use crate::{
-    queriers::{DaemonQuerier, Node},
+    queriers::{DaemonBankQuerier, DaemonNodeQuerier, DaemonQuerier, DaemonWasmQuerier, Node},
     CosmTxResponse, DaemonBuilder, DaemonError, DaemonState,
 };
 
-use cosmrs::tendermint::Time;
 use cosmwasm_std::{Addr, Coin};
 use cw_orch_core::{
     contract::{interface_traits::Uploadable, WasmPath},
-    environment::{
-        queriers::QueryHandler, ChainState, EnvironmentInfo, EnvironmentQuerier, TxHandler,
-    },
+    environment::{ChainState, DefaultQueriers, QueryHandler, TxHandler},
 };
 use cw_orch_traits::stargate::Stargate;
 use serde::Serialize;
@@ -218,40 +215,10 @@ impl QueryHandler for Daemon {
         }
         Ok(())
     }
-
-    fn block_info(&self) -> Result<cosmwasm_std::BlockInfo, DaemonError> {
-        let block = self
-            .rt_handle
-            .block_on(self.query_client::<Node>().latest_block())?;
-        let since_epoch = block.header.time.duration_since(Time::unix_epoch())?;
-        let time = cosmwasm_std::Timestamp::from_nanos(since_epoch.as_nanos() as u64);
-        Ok(cosmwasm_std::BlockInfo {
-            height: block.header.height.value(),
-            time,
-            chain_id: block.header.chain_id.to_string(),
-        })
-    }
-
-    fn query<
-        Q: serde::Serialize + std::fmt::Debug,
-        T: serde::Serialize + serde::de::DeserializeOwned,
-    >(
-        &self,
-        query_msg: &Q,
-        contract_address: &cosmwasm_std::Addr,
-    ) -> Result<T, Self::Error> {
-        self.rt_handle
-            .block_on(self.daemon.query(query_msg, contract_address))
-    }
 }
 
-impl EnvironmentQuerier for Daemon {
-    fn env_info(&self) -> EnvironmentInfo {
-        let state = &self.daemon.sender.daemon_state;
-        EnvironmentInfo {
-            chain_id: state.chain_data.chain_id.to_string(),
-            chain_name: state.chain_data.chain_name.clone(),
-            deployment_id: state.deployment_id.clone(),
-        }
-    }
+impl DefaultQueriers for Daemon {
+    type B = DaemonBankQuerier;
+    type W = DaemonWasmQuerier;
+    type N = DaemonNodeQuerier;
 }

cw-orch-daemon/tests/authz.rs

@@ -13,7 +13,7 @@ mod tests {
         bank::v1beta1::MsgSend,
     };
     use cosmwasm_std::coins;
-    use cw_orch_core::environment::{BankQuerier, TxHandler};
+    use cw_orch_core::environment::{BankQuerier, DefaultQueriers, QueryHandler, TxHandler};
     use cw_orch_daemon::{queriers::Authz, Daemon};
     use cw_orch_networks::networks::LOCAL_JUNO;
     use cw_orch_traits::Stargate;
@@ -138,8 +138,9 @@ mod tests {
 
         // the balance of the grantee whould be 6_000_000 or close
 
-        let grantee_balance =
-            daemon.balance(grantee.clone(), Some(LOCAL_JUNO.gas_denom.to_string()))?;
+        let grantee_balance = daemon
+            .bank_querier()
+            .balance(grantee.clone(), Some(LOCAL_JUNO.gas_denom.to_string()))?;
 
         assert_eq!(grantee_balance.first().unwrap().amount.u128(), 6_000_000);
 

cw-orch/examples/complex_osmosis_test_tube.rs

@@ -4,10 +4,7 @@ use counter_contract::{
     CounterContract, CounterExecuteMsgFns, CounterQueryMsgFns,
 };
 
-use cw_orch::prelude::bank::BankQuerier;
-use cw_orch::prelude::bank::BankQuerierGetter;
-use cw_orch::prelude::{CallAs, ContractInstance, OsmosisTestTube};
-use cw_orch::prelude::{CwOrchExecute, CwOrchInstantiate, CwOrchUpload};
+use cw_orch::prelude::*;
 use cw_orch_traits::Stargate;
 use osmosis_std::types::{
     cosmos::base::v1beta1::Coin,

cw-orch/examples/complex_testnet_daemon.rs

@@ -3,12 +3,7 @@ use counter_contract::{
     msg::{ExecuteMsg, GetCountResponse, InstantiateMsg, QueryMsg},
     CounterContract, CounterExecuteMsgFns, CounterQueryMsgFns,
 };
-use cw_orch::prelude::bank::BankQuerier;
-use cw_orch::prelude::bank::BankQuerierGetter;
-use cw_orch::prelude::{
-    ContractInstance, CwOrchExecute, CwOrchInstantiate, CwOrchQuery, CwOrchUpload, Daemon,
-    TxHandler,
-};
+use cw_orch::prelude::*;
 use cw_orch_traits::Stargate;
 use osmosis_std::types::{
     cosmos::base::v1beta1::Coin,

cw-orch/src/osmosis_test_tube/core.rs

@@ -2,8 +2,7 @@
 use crate::prelude::Uploadable;
 use cosmwasm_std::Addr;
 
-use cw_orch_core::environment::queriers::bank::{BankQuerier, BankQuerierGetter};
-use cw_orch_core::environment::BankSetter;
+use cw_orch_core::environment::{BankQuerier, BankSetter, DefaultQueriers};
 use cw_orch_traits::stargate::Stargate;
 
 use cosmwasm_std::{Binary, Coin, Uint128};
@@ -33,6 +32,8 @@
 
 pub use osmosis_test_tube;
 
+use super::queriers::bank::OsmosisTestTubeBankQuerier;
+
 /// Wrapper around a osmosis-test-tube [`OsmosisTestApp`](osmosis_test_tube::OsmosisTestApp) backend.
 ///
 /// Stores a local state with a mapping of contract_id -> code_id/address
@@ -65,7 +66,7 @@
     pub app: Rc<RefCell<OsmosisTestApp>>,
 }
 
 pub(crate) fn map_err(e: RunnerError) -> CwOrchError {
     CwOrchError::StdErr(e.to_string())
 }
 
@@ -139,10 +140,10 @@
     /// Query the (bank) balance of a native token for and address.
     /// Returns the amount of the native token.
     pub fn query_balance(&self, address: &str, denom: &str) -> Result<Uint128, CwOrchError> {
         let amount = self
             .bank_querier()
             .balance(address, Some(denom.to_string()))?;
         Ok(amount.first().unwrap().amount)
     }
 
     /// Fetch all the balances of an address.
@@ -150,7 +151,7 @@
         &self,
         address: &str,
     ) -> Result<Vec<cosmwasm_std::Coin>, CwOrchError> {
         let amount = self.bank_querier().balance(address, None)?;
         Ok(amount)
     }
 }
@@ -269,6 +270,8 @@
 }
 
 impl BankSetter for OsmosisTestTube {
+    type T = OsmosisTestTubeBankQuerier;
+
     /// It's impossible to set the balance of an address directly in OsmosisTestTub
     /// So for this implementation, we use a weird algorithm
     fn set_balance(
@@ -304,10 +307,7 @@
 pub mod tests {
     use cosmwasm_std::{coins, ContractInfoResponse};
 
-    use cw_orch_core::environment::queriers::{
-        bank::{BankQuerier, BankQuerierGetter},
-        wasm::{WasmQuerier, WasmQuerierGetter},
-    };
+    use cw_orch_core::environment::*;
     use osmosis_test_tube::Account;
 
     use super::OsmosisTestTube;

cw-orch/src/osmosis_test_tube/queriers/bank.rs

@@ -3,8 +3,7 @@
 use cosmwasm_std::coin;
 use cw_orch_core::{
     environment::{
-        queriers::bank::{BankQuerier, BankQuerierGetter},
-        StateInterface, TxHandler,
+        Querier, StateInterface, {BankQuerier, QuerierGetter},
     },
     CwEnvError,
 };
@@ -16,29 +15,29 @@
 use osmosis_test_tube::osmosis_std::types::cosmos::bank::v1beta1::{
     QueryAllBalancesRequest, QueryBalanceRequest,
 };
-pub struct MockBankQuerier {
+pub struct OsmosisTestTubeBankQuerier {
     app: Rc<RefCell<OsmosisTestApp>>,
 }
 
-impl MockBankQuerier {
+impl OsmosisTestTubeBankQuerier {
     fn new<S: StateInterface>(mock: &OsmosisTestTube<S>) -> Self {
         Self {
             app: mock.app.clone(),
         }
     }
 }
 
-impl<S: StateInterface> BankQuerierGetter<<Self as TxHandler>::Error> for OsmosisTestTube<S> {
-    type Querier = MockBankQuerier;
+impl Querier for OsmosisTestTubeBankQuerier {
+    type Error = CwEnvError;
+}
 
-    fn bank_querier(&self) -> Self::Querier {
-        MockBankQuerier::new(self)
+impl<S: StateInterface> QuerierGetter<OsmosisTestTubeBankQuerier> for OsmosisTestTube<S> {
+    fn querier(&self) -> OsmosisTestTubeBankQuerier {
+        OsmosisTestTubeBankQuerier::new(self)
     }
 }
 
-impl BankQuerier for MockBankQuerier {
-    type Error = CwEnvError;
-
+impl BankQuerier for OsmosisTestTubeBankQuerier {
     fn balance(
         &self,
         address: impl Into<String>,
@@ -60,15 +59,15 @@
                 .unwrap_or(coin(0, &denom));
             Ok(vec![amount])
         } else {
             let amount = Bank::new(&*self.app.borrow())
                 .query_all_balances(&QueryAllBalancesRequest {
                     address: address.into(),
                     pagination: None,
                 })
                 .map_err(map_err)?
                 .balances;
 
             Ok(try_proto_to_cosmwasm_coins(amount)?)
         }
     }
 
@@ -98,7 +97,7 @@
             .unwrap_or(coin(0, &denom)))
     }
 
     fn total_supply(&self) -> Result<Vec<cosmwasm_std::Coin>, Self::Error> {
         unimplemented!()
     }
 }

cw-orch/src/osmosis_test_tube/queriers/env.rs

@@ -1,16 +1,19 @@
-use crate::osmosis_test_tube::OsmosisTestTube;
-use cw_orch_core::environment::{EnvironmentInfo, EnvironmentQuerier, QueryHandler};
+use cw_orch_core::environment::{
+    EnvironmentInfo, EnvironmentQuerier, QueryHandler, StateInterface,
+};
 
-impl EnvironmentQuerier for OsmosisTestTube {
+use crate::prelude::OsmosisTestTube;
+
+impl<S: StateInterface> EnvironmentQuerier for OsmosisTestTube<S> {
     fn env_info(&self) -> EnvironmentInfo {
         let block = self.block_info().unwrap();
         let chain_id = block.chain_id;
         let chain_name = chain_id.rsplitn(2, '-').collect::<Vec<_>>()[1].to_string();
 
         EnvironmentInfo {
             chain_id,
             chain_name,
             deployment_id: "default".to_string(),
         }
     }
 }