Implement connection retry and timeout using tower-service

contracts/counter/examples/async.rs

@@ -13,7 +13,7 @@ pub async fn main() -> anyhow::Result<()> {
     pretty_env_logger::init(); // Used to log contract and chain interactions
 
     let network = networks::LOCAL_JUNO;
-    let chain = DaemonAsyncBuilder::default().chain(network).build().await?;
+    let chain = DaemonAsyncBuilder::new(network).build().await?;
 
     let counter = CounterContract::new(chain);
 

contracts/counter/examples/deploy.rs

@@ -13,7 +13,7 @@ pub fn main() -> anyhow::Result<()> {
     pretty_env_logger::init(); // Used to log contract and chain interactions
 
     let network = networks::LOCAL_JUNO;
-    let chain = DaemonBuilder::default().chain(network).build()?;
+    let chain = DaemonBuilder::new(network).build()?;
     // ANCHOR_END: chain_construction
 
     // ANCHOR: contract_interaction

contracts/counter/tests/osmosis-test-tube.rs

@@ -28,7 +28,7 @@ fn setup<Chain: CwEnv>(chain: Chain) -> CounterContract<Chain> {
     // Instantiate the contract
     let msg = InstantiateMsg { count: 1i32 };
     let init_resp = contract
-        .instantiate(&msg, Some(&chain.sender()), None)
+        .instantiate(&msg, Some(&chain.sender_addr()), None)
         .unwrap();
 
     // Get the address from the response

cw-orch-daemon/Cargo.toml

@@ -56,7 +56,7 @@ chrono = { version = "0.4" }
 base16 = { version = "0.2.1" }
 ring = { version = "0.17.3" }
 dirs = "5.0.1"
-
+tower = { version = "0.4", features = ["retry", "reconnect"] }
 
 # Injective dependencies
 ethers-signers = { version = "2.0.7", optional = true }
@@ -66,6 +66,8 @@ async-recursion = "1.0.5"
 # Gzip
 flate2 = { version = "1.0.26" }
 lazy_static = "1.4.0"
+http = "0.2.11"
+hyper = "0.14.27"
 
 # Lock daemon
 file-lock = { version = "2.1.10" }
@@ -74,6 +76,7 @@ regex = "1.10.4"
 
 [dev-dependencies]
 cw-orch-daemon = { path = "." }
+cw-orch = { path = "../cw-orch", features = ["daemon"] }
 uid = "0.1.7"
 env_logger = "0.11.2"
 cw20 = { version = "1" }
@@ -94,3 +97,6 @@ tokio-test = "0.4.3"
 
 # File lock test
 nix = { version = "0.28.0", features = ["process"] }
+counter-contract = { path = "../contracts/counter" }
+dotenv = "0.15.0"
+pretty_env_logger = "0.5.0"

cw-orch-daemon/examples/batch-sender.rs

@@ -0,0 +1,49 @@
+// ANCHOR: full_counter_example
+use counter_contract::{
+    msg::InstantiateMsg, CounterContract, CounterExecuteMsgFns, CounterQueryMsgFns,
+};
+use cw_orch::{anyhow, daemon::senders::BatchDaemon, prelude::*};
+use cw_orch_daemon::senders::CosmosBatchOptions;
+
+// From https://github.com/CosmosContracts/juno/blob/32568dba828ff7783aea8cb5bb4b8b5832888255/docker/test-user.env#L2
+const LOCAL_MNEMONIC: &str = "clip hire initial neck maid actor venue client foam budget lock catalog sweet steak waste crater broccoli pipe steak sister coyote moment obvious choose";
+pub fn main() -> anyhow::Result<()> {
+    std::env::set_var("LOCAL_MNEMONIC", LOCAL_MNEMONIC);
+    dotenv::dotenv().ok(); // Used to load the `.env` file if any
+    pretty_env_logger::init(); // Used to log contract and chain interactions
+
+    let network = networks::LOCAL_JUNO;
+    let chain: BatchDaemon =
+        BatchDaemon::builder(network).build_sender(CosmosBatchOptions::default())?;
+
+    let counter = CounterContract::new(chain.clone());
+
+    counter.upload()?;
+    counter.instantiate(&InstantiateMsg { count: 0 }, None, None)?;
+
+    counter.increment()?;
+
+    // The count hasn't been incremented yet, we didn't broadcast the tx
+    let count = counter.get_count()?;
+    assert_eq!(count.count, 0);
+
+    chain.rt_handle.block_on(chain.sender().broadcast(None))?;
+
+    let count = counter.get_count()?;
+    assert_eq!(count.count, 1);
+
+    // Increment multiple times in the same transaction
+    counter.increment()?;
+    counter.increment()?;
+    counter.increment()?;
+    counter.increment()?;
+    counter.increment()?;
+    counter.increment()?;
+
+    chain.rt_handle.block_on(chain.sender().broadcast(None))?;
+
+    let count = counter.get_count()?;
+    assert_eq!(count.count, 7);
+
+    Ok(())
+}

cw-orch-daemon/examples/daemon-capabilities.rs

@@ -3,6 +3,7 @@ use std::str::FromStr;
 use cosmrs::{tx::Msg, AccountId, Coin, Denom};
 use cosmwasm_std::coins;
 // ANCHOR: full_counter_example
+use cw_orch_daemon::senders::tx::TxSender;
 use cw_orch_daemon::DaemonBuilder;
 use cw_orch_networks::networks;
 
@@ -12,13 +13,14 @@ pub fn main() -> anyhow::Result<()> {
     std::env::set_var("LOCAL_MNEMONIC", LOCAL_MNEMONIC);
 
     let network = networks::LOCAL_JUNO;
-    let mut daemon = DaemonBuilder::default().chain(network).build()?;
+    let mut daemon = DaemonBuilder::new(network).build()?;
 
     daemon.flush_state()?;
 
     // We commit the tx (also resimulates the tx)
     // ANCHOR: send_tx
-    let wallet = daemon.wallet();
+    let wallet = daemon.sender();
+
     let rt = daemon.rt_handle.clone();
     rt.block_on(wallet.bank_send("<address-of-my-sister>", coins(345, "ujunox")))?;
     // ANCHOR_END: send_tx

cw-orch-daemon/examples/manual_sender.rs

@@ -0,0 +1,196 @@
+// This file illustrates an example for custom sender inside Daemon
+
+use cw_orch_daemon::proto::injective::InjectiveEthAccount;
+use cw_orch_daemon::queriers::Node;
+use cw_orch_daemon::senders::builder::SenderBuilder;
+use cw_orch_daemon::senders::query::QuerySender;
+use cw_orch_daemon::tx_broadcaster::assert_broadcast_code_cosm_response;
+use cw_orch_daemon::{DaemonBase, GrpcChannel, TxBuilder};
+
+use cw_orch_daemon::{CosmTxResponse, DaemonError};
+
+use cosmrs::proto::cosmos;
+use cosmrs::proto::cosmos::auth::v1beta1::BaseAccount;
+use cosmrs::proto::cosmos::vesting::v1beta1::PeriodicVestingAccount;
+use cosmrs::tendermint::chain::Id;
+use cosmrs::tx::{ModeInfo, Raw, SignDoc, SignMode, SignerInfo};
+use cosmrs::{AccountId, Any};
+use cosmwasm_std::Addr;
+use cw_orch::prelude::*;
+use cw_orch_core::environment::ChainInfoOwned;
+use prost::Message;
+use std::io::{self, Write};
+use std::sync::Arc;
+use tonic::transport::Channel;
+
+// ANCHOR: full_counter_example
+use counter_contract::CounterContract;
+
+// This is a test with a manual sender, to verify everything works, nothing is broadcasted
+
+pub fn main() -> anyhow::Result<()> {
+    dotenv::dotenv().ok(); // Used to load the `.env` file if any
+    pretty_env_logger::init(); // Used to log contract and chain interactions
+
+    let network = cw_orch_networks::networks::JUNO_1;
+    let sender = "juno1xjf5xscdk08c5es2m7epmerrpqmkmc3n98650t";
+    let chain: ManualDaemon = ManualDaemon::builder(network).build_sender(ManualSenderOptions {
+        sender_address: sender.to_string(),
+    })?;
+
+    let counter = CounterContract::new(chain.clone());
+
+    // Example tx hash that succeed (correspond to a code upload tx)
+    // 58AA802705BEE4597A560FBC67F6C86400E66F5FCBD0F08AA37FB140BCD65B6D
+    // If not found, try to find the latests juno code uploaded (4380+)
+    // https://www.mintscan.io/juno/wasm/code/4380
+    counter.upload()?;
+
+    Ok(())
+}
+
+use cw_orch_daemon::senders::tx::TxSender;
+
+pub type ManualDaemon = DaemonBase<ManualSender>;
+
+#[derive(Clone, Default)]
+pub struct ManualSenderOptions {
+    pub sender_address: String,
+}
+
+/// Signer of the transactions and helper for address derivation
+/// This is the main interface for simulating and signing transactions
+#[derive(Clone)]
+pub struct ManualSender {
+    pub sender: Addr,
+    pub chain_info: Arc<ChainInfoOwned>,
+    pub grpc_channel: Channel,
+}
+
+impl SenderBuilder for ManualSenderOptions {
+    type Error = DaemonError;
+    type Sender = ManualSender;
+
+    async fn build(&self, chain_info: &Arc<ChainInfoOwned>) -> Result<ManualSender, Self::Error> {
+        let grpc_channel = GrpcChannel::from_chain_info(chain_info.as_ref()).await?;
+        Ok(ManualSender {
+            chain_info: chain_info.clone(),
+            sender: Addr::unchecked(self.sender_address.clone()),
+            grpc_channel,
+        })
+    }
+}
+
+impl QuerySender for ManualSender {
+    type Error = DaemonError;
+    type Options = ManualSenderOptions;
+
+    fn channel(&self) -> tonic::transport::Channel {
+        self.grpc_channel.clone()
+    }
+}
+
+impl TxSender for ManualSender {
+    async fn commit_tx_any(
+        &self,
+        msgs: Vec<Any>,
+        memo: Option<&str>,
+    ) -> Result<CosmTxResponse, DaemonError> {
+        // We print the any messages to broadcast
+        println!("Here is the transaction to sign and broadcast: ");
+        println!("{:?}", msgs);
+        // We simulate
+        let gas_needed = self.simulate(msgs, memo).await?;
+        println!("Gas needed: {}", gas_needed);
+
+        // We wait for the txhash as input to be able to continue the execution
+        println!("Enter the txhash to proceed");
+        let mut txhash = String::new();
+        io::stdout().flush().unwrap(); // Ensure the prompt is displayed
+        io::stdin()
+            .read_line(&mut txhash)
+            .expect("Failed to read line");
+        let txhash = txhash.trim_end();
+
+        let resp = Node::new_async(self.channel())
+            ._find_tx(txhash.to_string())
+            .await?;
+
+        assert_broadcast_code_cosm_response(resp)
+    }
+
+    fn account_id(&self) -> AccountId {
+        self.sender.clone().to_string().parse().unwrap()
+    }
+}
+
+impl ManualSender {
+    pub async fn simulate(&self, msgs: Vec<Any>, memo: Option<&str>) -> Result<u64, DaemonError> {
+        let timeout_height = Node::new_async(self.channel())._block_height().await? + 10u64;
+
+        let tx_body = TxBuilder::build_body(msgs, memo, timeout_height);
+
+        let fee = TxBuilder::build_fee(0u8, &self.chain_info.gas_denom, 0, None)?;
+
+        let BaseAccount {
+            account_number,
+            sequence,
+            pub_key,
+            ..
+        } = self.base_account().await?;
+
+        let auth_info = SignerInfo {
+            public_key: pub_key.map(|key| key.try_into()).transpose()?,
+            mode_info: ModeInfo::single(SignMode::Direct),
+            sequence,
+        }
+        .auth_info(fee);
+
+        let sign_doc = SignDoc::new(
+            &tx_body,
+            &auth_info,
+            &Id::try_from(self.chain_info.chain_id.to_string())?,
+            account_number,
+        )?;
+
+        let tx_raw: Raw = cosmos::tx::v1beta1::TxRaw {
+            body_bytes: sign_doc.body_bytes,
+            auth_info_bytes: sign_doc.auth_info_bytes,
+            signatures: vec![vec![]],
+        }
+        .into();
+
+        Node::new_async(self.channel())
+            ._simulate_tx(tx_raw.to_bytes()?)
+            .await
+    }
+
+    async fn base_account(&self) -> Result<BaseAccount, DaemonError> {
+        let addr = self.address().to_string();
+
+        let mut client =
+            cosmrs::proto::cosmos::auth::v1beta1::query_client::QueryClient::new(self.channel());
+
+        let resp = client
+            .account(cosmrs::proto::cosmos::auth::v1beta1::QueryAccountRequest { address: addr })
+            .await?
+            .into_inner();
+
+        let account = resp.account.unwrap().value;
+
+        let acc = if let Ok(acc) = BaseAccount::decode(account.as_ref()) {
+            acc
+        } else if let Ok(acc) = PeriodicVestingAccount::decode(account.as_ref()) {
+            // try vesting account, (used by Terra2)
+            acc.base_vesting_account.unwrap().base_account.unwrap()
+        } else if let Ok(acc) = InjectiveEthAccount::decode(account.as_ref()) {
+            acc.base_account.unwrap()
+        } else {
+            return Err(DaemonError::StdErr(
+                "Unknown account type returned from QueryAccountRequest".into(),
+            ));
+        };
+
+        Ok(acc)
+    }
+}

cw-orch-daemon/examples/querier-daemon.rs

@@ -0,0 +1,20 @@
+// ANCHOR: full_counter_example
+
+use cw_orch::{anyhow, prelude::*};
+use cw_orch_daemon::senders::QueryOnlyDaemon;
+
+// From https://github.com/CosmosContracts/juno/blob/32568dba828ff7783aea8cb5bb4b8b5832888255/docker/test-user.env#L1
+pub const LOCAL_JUNO_SENDER: &str = "juno16g2rahf5846rxzp3fwlswy08fz8ccuwk03k57y";
+
+pub fn main() -> anyhow::Result<()> {
+    pretty_env_logger::init(); // Used to log contract and chain interactions
+
+    let network = networks::LOCAL_JUNO;
+    // There is no need to register a mnemonic to use this daemon querier
+    let chain: QueryOnlyDaemon = QueryOnlyDaemon::builder(network).build_sender(())?;
+
+    let balances = chain.bank_querier().balance(LOCAL_JUNO_SENDER, None)?;
+    assert!(!balances.is_empty());
+
+    Ok(())
+}