Added instantiate2

cw-orch-daemon/src/core.rs

@@ -11,16 +11,18 @@
 
 use cosmrs::{
     cosmwasm::{MsgExecuteContract, MsgInstantiateContract, MsgMigrateContract},
+    proto::cosmwasm::wasm::v1::MsgInstantiateContract2,
     tendermint::Time,
-    AccountId, Denom,
+    AccountId, Any, Denom,
 };
-use cosmwasm_std::{Addr, Coin};
+use cosmwasm_std::{Addr, Binary, Coin};
 use cw_orch_core::{
     contract::interface_traits::Uploadable,
     environment::{ChainState, IndexResponse},
     log::transaction_target,
 };
 use flate2::{write, Compression};
+use prost::Message;
 use serde::{de::DeserializeOwned, Serialize};
 use serde_json::from_str;
 use std::{
@@ -162,6 +164,44 @@
         Ok(result)
     }
 
+    /// Instantiate a contract.
+    pub async fn instantiate2<I: Serialize + Debug>(
+        &self,
+        code_id: u64,
+        init_msg: &I,
+        label: Option<&str>,
+        admin: Option<&Addr>,
+        coins: &[Coin],
+        salt: Binary,
+    ) -> Result<CosmTxResponse, DaemonError> {
+        let sender = &self.sender;
+
+        let init_msg = MsgInstantiateContract2 {
+            code_id,
+            label: label.unwrap_or("instantiate_contract").to_string(),
+            admin: admin.map(Into::into).unwrap_or_default(),
+            sender: sender.address()?.to_string(),
+            msg: serde_json::to_vec(&init_msg)?,
+            funds: proto_parse_cw_coins(coins)?,
+            salt: salt.to_vec(),
+            fix_msg: false,
+        };
+
+        let result = sender
+            .commit_tx_any(
+                vec![Any {
+                    type_url: "/cosmwasm.wasm.v1.MsgInstantiateContract2".to_string(),
+                    value: init_msg.encode_to_vec(),
+                }],
+                None,
+            )
+            .await?;
+
+        log::info!(target: &transaction_target(), "Instantiation done: {:?}", result.txhash);
+
+        Ok(result)
+    }
+
     /// Query a contract.
     pub async fn query<Q: Serialize + Debug, T: Serialize + DeserializeOwned>(
         &self,
@@ -299,3 +339,17 @@
         })
         .collect::<Result<Vec<_>, DaemonError>>()
 }
+
+pub(crate) fn proto_parse_cw_coins(
+    coins: &[cosmwasm_std::Coin],
+) -> Result<Vec<cosmrs::proto::cosmos::base::v1beta1::Coin>, DaemonError> {
+    coins
+        .iter()
+        .map(|cosmwasm_std::Coin { amount, denom }| {
+            Ok(cosmrs::proto::cosmos::base::v1beta1::Coin {
+                amount: amount.to_string(),
+                denom: denom.clone(),
+            })
+        })
+        .collect::<Result<Vec<_>, DaemonError>>()
+}

cw-orch-daemon/src/error.rs

@@ -1,6 +1,6 @@
 #![allow(missing_docs)]
 
-use cosmwasm_std::Coin;
+use cosmwasm_std::{Coin, Instantiate2AddressError};
 use cw_orch_core::CwEnvError;
 use thiserror::Error;
 
@@ -118,6 +118,8 @@ pub enum DaemonError {
     NotEnoughBalance { expected: Coin, current: Coin },
     #[error("Can't set the daemon state, it's read-only")]
     StateReadOnly,
+    #[error(transparent)]
+    Instantiate2Error(#[from] Instantiate2AddressError),
 }
 
 impl DaemonError {

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

@@ -1,12 +1,17 @@
+use std::str::FromStr;
+
+use super::DaemonQuerier;
 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 cosmrs::AccountId;
+use cosmwasm_std::{
+    from_json, instantiate2_address, to_json_binary, CanonicalAddr, CodeInfoResponse,
+    ContractInfoResponse,
+};
 use cw_orch_core::environment::{Querier, QuerierGetter, WasmQuerier};
 use tokio::runtime::Handle;
 use tonic::transport::Channel;
 
-use super::DaemonQuerier;
-
 /// Querier for the CosmWasm SDK module
 pub struct CosmWasm {
     channel: Channel,
@@ -265,4 +270,20 @@
 
         Ok(c)
     }
+
+    fn instantiate2_addr<I: serde::Serialize + std::fmt::Debug>(
+        &self,
+        code_id: u64,
+        creator: impl Into<String>,
+        salt: cosmwasm_std::Binary,
+    ) -> Result<String, Self::Error> {
+        let creator_str = creator.into();
+        let account_id = AccountId::from_str(&creator_str)?;
+        let prefix = account_id.prefix();
+        let canon = account_id.to_bytes();
+        let checksum = self.code_id_hash(code_id)?;
+        let addr = instantiate2_address(checksum.as_bytes(), &CanonicalAddr(canon.into()), &salt)?;
+
+        Ok(AccountId::new(prefix, &addr.0)?.to_string())
+    }
 }

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

@@ -146,6 +146,21 @@ impl TxHandler for Daemon {
                 .migrate(migrate_msg, new_code_id, contract_address),
         )
     }
+
+    fn instantiate2<I: Serialize + Debug>(
+        &self,
+        code_id: u64,
+        init_msg: &I,
+        label: Option<&str>,
+        admin: Option<&Addr>,
+        coins: &[cosmwasm_std::Coin],
+        salt: cosmwasm_std::Binary,
+    ) -> Result<Self::Response, Self::Error> {
+        self.rt_handle.block_on(
+            self.daemon
+                .instantiate2(code_id, init_msg, label, admin, coins, salt),
+        )
+    }
 }
 
 impl Stargate for Daemon {

cw-orch-daemon/tests/instantiate2.rs

@@ -0,0 +1,36 @@
+mod common;
+
+#[cfg(feature = "node-tests")]
+pub mod test {
+
+    use cosmwasm_std::Binary;
+    use cw_orch_core::contract::interface_traits::ContractInstance;
+    use cw_orch_core::contract::interface_traits::CwOrchInstantiate;
+    use cw_orch_core::contract::interface_traits::CwOrchUpload;
+    use cw_orch_daemon::Daemon;
+    use cw_orch_networks::networks;
+    use mock_contract::InstantiateMsg;
+    use mock_contract::MockContract;
+
+    #[test]
+    fn instantiate2() -> anyhow::Result<()> {
+        let runtime = tokio::runtime::Runtime::new().unwrap();
+
+        let app = Daemon::builder()
+            .chain(networks::LOCAL_JUNO)
+            .handle(runtime.handle())
+            .build()
+            .unwrap();
+
+        let salt = Binary(vec![12, 89, 156, 63]);
+        let mock_contract = MockContract::new("mock-contract", app.clone());
+
+        mock_contract.upload()?;
+
+        mock_contract.instantiate2(&InstantiateMsg {}, None, None, salt.clone())?;
+
+        mock_contract.address()?;
+
+        Ok(())
+    }
+}

cw-orch/src/osmosis_test_tube/core.rs

@@ -267,6 +267,18 @@
     ) -> Result<Self::Response, CwOrchError> {
         panic!("Migrate not implemented on osmosis test_tube")
     }
+
+    fn instantiate2<I: Serialize + Debug>(
+        &self,
+        _code_id: u64,
+        _init_msg: &I,
+        _label: Option<&str>,
+        _admin: Option<&Addr>,
+        _coins: &[cosmwasm_std::Coin],
+        _salt: Binary,
+    ) -> Result<Self::Response, Self::Error> {
+        unimplemented!("Osmosis Test Tube doesn't support Instantiate 2 directly");
+    }
 }
 
 impl BankSetter for OsmosisTestTube {

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

@@ -1,6 +1,10 @@
-use std::{cell::RefCell, rc::Rc};
+use std::{cell::RefCell, rc::Rc, str::FromStr};
 
-use cosmwasm_std::{from_json, to_json_vec, CodeInfoResponse, ContractInfoResponse};
+use cosmrs::AccountId;
+use cosmwasm_std::{
+    from_json, instantiate2_address, to_json_vec, CanonicalAddr, CodeInfoResponse,
+    ContractInfoResponse,
+};
 use cw_orch_core::{
     environment::{Querier, QuerierGetter, StateInterface, WasmQuerier},
     CwEnvError,
@@ -152,4 +156,22 @@
 
         Ok(c)
     }
+
+    fn instantiate2_addr<I: serde::Serialize + std::fmt::Debug>(
+        &self,
+        code_id: u64,
+        creator: impl Into<String>,
+        salt: cosmwasm_std::Binary,
+    ) -> Result<String, Self::Error> {
+        let checksum = self.code_id_hash(code_id)?;
+
+        let creator_str = creator.into();
+        let account_id = AccountId::from_str(&creator_str).unwrap();
+        let prefix = account_id.prefix();
+        let canon = account_id.to_bytes();
+        let addr =
+            instantiate2_address(checksum.as_bytes(), &CanonicalAddr(canon.into()), &salt).unwrap();
+
+        Ok(AccountId::new(prefix, &addr.0).unwrap().to_string())
+    }
 }

packages/cw-orch-core/src/contract/contract_instance.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 
 use crate::environment::QueryHandler;
-use cosmwasm_std::{Addr, Coin};
+use cosmwasm_std::{Addr, Binary, Coin};
 use serde::{de::DeserializeOwned, Serialize};
 use std::fmt::Debug;
 
@@ -171,6 +171,58 @@ impl<Chain: TxHandler + QueryHandler + Clone> Contract<Chain> {
         Ok(resp)
     }
 
+    /// Initializes the contract
+    pub fn instantiate2<I: Serialize + Debug>(
+        &self,
+        msg: &I,
+        admin: Option<&Addr>,
+        coins: Option<&[Coin]>,
+        salt: Binary,
+    ) -> Result<TxResponse<Chain>, CwEnvError> {
+        log::info!(
+            target: &contract_target(),
+            "[{}][Instantiate]",
+            self.id,
+        );
+
+        log::debug!(
+            target: &contract_target(),
+            "[{}][Instantiate] {}",
+            self.id,
+            log_serialize_message(msg)?
+        );
+
+        let resp = self
+            .chain
+            .instantiate2(
+                self.code_id()?,
+                msg,
+                Some(&self.id),
+                admin,
+                coins.unwrap_or(&[]),
+                salt,
+            )
+            .map_err(Into::into)?;
+        let contract_address = resp.instantiated_contract_address()?;
+
+        self.set_address(&contract_address);
+
+        log::info!(
+            target: &&contract_target(),
+            "[{}][Instantiated] {}",
+            self.id,
+            contract_address
+        );
+        log::debug!(
+            target: &&transaction_target(),
+            "[{}][Instantiated] response: {:?}",
+            self.id,
+            resp
+        );
+
+        Ok(resp)
+    }
+
     /// Query the contract
     pub fn query<Q: Serialize + Debug, T: Serialize + DeserializeOwned + Debug>(
         &self,

packages/cw-orch-core/src/contract/interface_traits.rs

@@ -4,7 +4,7 @@ use crate::{
     error::CwEnvError,
     log::contract_target,
 };
-use cosmwasm_std::{Addr, Coin, Empty};
+use cosmwasm_std::{Addr, Binary, Coin, Empty};
 use cw_multi_test::Contract as MockContract;
 use serde::{de::DeserializeOwned, Serialize};
 use std::fmt::Debug;
@@ -118,6 +118,18 @@ pub trait CwOrchInstantiate<Chain: CwEnv>: InstantiableContract + ContractInstan
         self.as_instance()
             .instantiate(instantiate_msg, admin, coins)
     }
+
+    /// Instantiates the contract using instantiate2
+    fn instantiate2(
+        &self,
+        instantiate_msg: &Self::InstantiateMsg,
+        admin: Option<&Addr>,
+        coins: Option<&[Coin]>,
+        salt: Binary,
+    ) -> Result<Chain::Response, CwEnvError> {
+        self.as_instance()
+            .instantiate2(instantiate_msg, admin, coins, salt)
+    }
 }
 
 impl<T: InstantiableContract + ContractInstance<Chain>, Chain: CwEnv> CwOrchInstantiate<Chain>

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

@@ -2,7 +2,7 @@
 
 use super::{queriers::QueryHandler, ChainState, IndexResponse};
 use crate::{contract::interface_traits::Uploadable, error::CwEnvError};
-use cosmwasm_std::{Addr, Coin};
+use cosmwasm_std::{Addr, Binary, Coin};
 use serde::Serialize;
 use std::fmt::Debug;
 
@@ -46,6 +46,17 @@
         coins: &[cosmwasm_std::Coin],
     ) -> Result<Self::Response, Self::Error>;
 
+    /// Send a Instantiate2Msg to a contract.
+    fn instantiate2<I: Serialize + Debug>(
+        &self,
+        code_id: u64,
+        init_msg: &I,
+        label: Option<&str>,
+        admin: Option<&Addr>,
+        coins: &[cosmwasm_std::Coin],
+        salt: Binary,
+    ) -> Result<Self::Response, Self::Error>;
+
     /// Send a ExecMsg to a contract.
     fn execute<E: Serialize + Debug>(
         &self,
@@ -169,6 +180,18 @@
         ) -> Result<Self::Response, Self::Error> {
             unimplemented!()
         }
+
+        fn instantiate2<I: Serialize + Debug>(
+            &self,
+            _code_id: u64,
+            _init_msg: &I,
+            _label: Option<&str>,
+            _admin: Option<&Addr>,
+            _coins: &[cosmwasm_std::Coin],
+            _salt: Binary,
+        ) -> Result<Self::Response, Self::Error> {
+            unimplemented!()
+        }
     }
 
     fn associated_error<T: TxHandler>(t: T) -> anyhow::Result<()> {