Replaced rc by arc in daemon

cw-orch-daemon/src/builder.rs

@@ -1,5 +1,5 @@
 use crate::{log::print_if_log_disabled, DaemonAsync, DaemonBuilder};
-use std::rc::Rc;
+use std::sync::Arc;
 
 use ibc_chain_registry::chain::ChainData;
 
@@ -63,7 +63,7 @@ impl DaemonAsyncBuilder {
             .deployment_id
             .clone()
             .unwrap_or(DEFAULT_DEPLOYMENT.to_string());
-        let state = Rc::new(DaemonState::new(chain, deployment_id, false).await?);
+        let state = Arc::new(DaemonState::new(chain, deployment_id, false).await?);
         // if mnemonic provided, use it. Else use env variables to retrieve mnemonic
         let sender = if let Some(mnemonic) = &self.mnemonic {
             Sender::from_mnemonic(&state, mnemonic)?
@@ -72,7 +72,7 @@ impl DaemonAsyncBuilder {
         };
         let daemon = DaemonAsync {
             state,
-            sender: Rc::new(sender),
+            sender: Arc::new(sender),
         };
         print_if_log_disabled()?;
         Ok(daemon)

cw-orch-daemon/src/core.rs

@@ -26,8 +26,8 @@ use serde_json::from_str;
 use std::{
     fmt::Debug,
     io::Write,
-    rc::Rc,
     str::{from_utf8, FromStr},
+    sync::Arc,
     time::Duration,
 };
 
@@ -62,7 +62,7 @@ pub struct DaemonAsync {
     /// Sender to send transactions to the chain
     pub sender: Wallet,
     /// State of the daemon
-    pub state: Rc<DaemonState>,
+    pub state: Arc<DaemonState>,
 }
 
 impl DaemonAsync {
@@ -84,7 +84,7 @@ impl DaemonAsync {
 }
 
 impl ChainState for DaemonAsync {
-    type Out = Rc<DaemonState>;
+    type Out = Arc<DaemonState>;
 
     fn state(&self) -> Self::Out {
         self.state.clone()

cw-orch-daemon/src/sender.rs

@@ -34,7 +34,7 @@ use cosmwasm_std::{coin, Addr, Coin};
 use cw_orch_core::{log::local_target, CwOrchEnvVars};
 
 use bitcoin::secp256k1::{All, Context, Secp256k1, Signing};
-use std::{convert::TryFrom, rc::Rc, str::FromStr};
+use std::{convert::TryFrom, str::FromStr, sync::Arc};
 
 use cosmos_modules::vesting::PeriodicVestingAccount;
 use tonic::transport::Channel;
@@ -44,18 +44,18 @@ const BUFFER_THRESHOLD: u64 = 200_000;
 const SMALL_GAS_BUFFER: f64 = 1.4;
 
 /// A wallet is a sender of transactions, can be safely cloned and shared within the same thread.
-pub type Wallet = Rc<Sender<All>>;
+pub type Wallet = Arc<Sender<All>>;
 
 /// Signer of the transactions and helper for address derivation
 /// This is the main interface for simulating and signing transactions
 pub struct Sender<C: Signing + Context> {
     pub private_key: PrivateKey,
     pub secp: Secp256k1<C>,
-    pub(crate) daemon_state: Rc<DaemonState>,
+    pub(crate) daemon_state: Arc<DaemonState>,
 }
 
 impl Sender<All> {
-    pub fn new(daemon_state: &Rc<DaemonState>) -> Result<Sender<All>, DaemonError> {
+    pub fn new(daemon_state: &Arc<DaemonState>) -> Result<Sender<All>, DaemonError> {
         let kind = ChainKind::from(daemon_state.chain_data.network_type.clone());
         // NETWORK_MNEMONIC_GROUP
         let env_variable_name = kind.mnemonic_env_variable_name();
@@ -71,7 +71,7 @@ impl Sender<All> {
 
     /// Construct a new Sender from a mnemonic
     pub fn from_mnemonic(
-        daemon_state: &Rc<DaemonState>,
+        daemon_state: &Arc<DaemonState>,
         mnemonic: &str,
     ) -> Result<Sender<All>, DaemonError> {
         let secp = Secp256k1::new();

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

@@ -1,4 +1,4 @@
-use std::{fmt::Debug, rc::Rc, time::Duration};
+use std::{fmt::Debug, sync::Arc, time::Duration};
 
 use super::super::{sender::Wallet, DaemonAsync};
 use crate::{
@@ -74,7 +74,7 @@ impl Daemon {
 }
 
 impl ChainState for Daemon {
-    type Out = Rc<DaemonState>;
+    type Out = Arc<DaemonState>;
 
     fn state(&self) -> Self::Out {
         self.daemon.state.clone()

packages/cw-orch-core/src/environment/state.rs

@@ -2,7 +2,7 @@
 
 use crate::error::CwEnvError;
 use cosmwasm_std::Addr;
-use std::{cell::RefCell, collections::HashMap, rc::Rc};
+use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::Arc};
 
 /// State accessor trait.
 /// Indicates that the type has access to an underlying state.
@@ -107,3 +107,33 @@
         (**self).deploy_details()
     }
 }
+
+impl<S: StateInterface> StateInterface for Arc<S> {
+    fn get_address(&self, contract_id: &str) -> Result<Addr, CwEnvError> {
+        (**self).get_address(contract_id)
+    }
+
+    fn set_address(&mut self, contract_id: &str, address: &Addr) {
+        (*Arc::make_mut(self)).set_address(contract_id, address)
+    }
+
+    fn get_code_id(&self, contract_id: &str) -> Result<u64, CwEnvError> {
+        (**self).get_code_id(contract_id)
+    }
+
+    fn set_code_id(&mut self, contract_id: &str, code_id: u64) {
+        (*Arc::make_mut(self)).set_code_id(contract_id, code_id)
+    }
+
+    fn get_all_addresses(&self) -> Result<HashMap<String, Addr>, CwEnvError> {
+        (**self).get_all_addresses()
+    }
+
+    fn get_all_code_ids(&self) -> Result<HashMap<String, u64>, CwEnvError> {
+        (**self).get_all_code_ids()
+    }
+
+    fn deploy_details(&self) -> DeployDetails {
+        (**self).deploy_details()
+    }
+}