Support for signing wasm/MsgInstantiateContract transactions (#4368)

* my tracked commit

* MsgInstantiateContract

* revert formatting

* test

* Tests fixes and broadcast

* cargo fmt

* remove unused

---------

Co-authored-by: gupnik <[email protected]>

Author: enriquesouza

rust/tw_cosmos_sdk/Protobuf/cosmwasm_wasm_v1_tx.proto

@@ -17,3 +17,12 @@ message MsgExecuteContract {
     // Gap in field numbering is intentional!
     repeated cosmos.base.v1beta1.Coin funds = 5;
 }
+
+message MsgInstantiateContract {
+    string sender = 1;
+    string admin = 2; // optional
+    uint64 code_id = 3;
+    string label = 4;
+    bytes msg = 5; // JSON
+    repeated cosmos.base.v1beta1.Coin init_funds = 6;
+}

rust/tw_cosmos_sdk/src/modules/tx_builder.rs

@@ -237,6 +237,9 @@ where
             },
             MessageEnum::None => SigningError::err(SigningErrorType::Error_invalid_params)
                 .context("No TX message provided"),
+            MessageEnum::wasm_instantiate_contract_message(ref generic) => {
+                Self::wasm_instantiate_contract_generic_msg_from_proto(coin, generic)
+            },
         }
     }
 
@@ -601,6 +604,50 @@ where
         Ok(msg.into_boxed())
     }
 
+    pub fn wasm_instantiate_contract_generic_msg_from_proto(
+        _coin: &dyn CoinContext,
+        generic: &Proto::mod_Message::WasmInstantiateContract<'_>,
+    ) -> SigningResult<CosmosMessageBox> {
+        use crate::transaction::message::wasm_message_instantiate_contract::{
+            InstantiateMsg, WasmInstantiateContractMessage,
+        };
+
+        let funds = generic
+            .init_funds
+            .iter()
+            .map(Self::coin_from_proto)
+            .collect::<SigningResult<_>>()?;
+
+        let sender = Address::from_str(&generic.sender)
+            .into_tw()
+            .context("Invalid sender address")?;
+
+        let admin = if generic.admin.is_empty() {
+            None
+        } else {
+            Some(
+                Address::from_str(&generic.admin)
+                    .into_tw()
+                    .context("Invalid admin address")?,
+            )
+        };
+
+        let msg = WasmInstantiateContractMessage {
+            sender,
+            admin,
+            code_id: generic.code_id,
+            label: generic.label.to_string(),
+            msg: InstantiateMsg::Json(
+                serde_json::from_slice(&generic.msg)
+                    .into_tw()
+                    .context("Invalid JSON in msg")?,
+            ),
+            funds,
+        };
+
+        Ok(msg.into_boxed())
+    }
+
     pub fn thorchain_send_msg_from_proto(
         _coin: &dyn CoinContext,
         send: &Proto::mod_Message::THORChainSend<'_>,

rust/tw_cosmos_sdk/src/transaction/message/mod.rs

@@ -18,6 +18,7 @@ pub mod stride_message;
 pub mod terra_wasm_message;
 pub mod thorchain_message;
 pub mod wasm_message;
+pub mod wasm_message_instantiate_contract;
 
 pub type ProtobufMessage = google::protobuf::Any<'static>;
 pub type CosmosMessageBox = Box<dyn CosmosMessage>;

rust/tw_cosmos_sdk/src/transaction/message/wasm_message_instantiate_contract.rs

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::address::CosmosAddress;
+use crate::modules::serializer::protobuf_serializer::build_coin;
+use crate::proto::cosmwasm;
+use crate::transaction::message::{CosmosMessage, JsonMessage, ProtobufMessage};
+use crate::transaction::Coin;
+use serde::Serialize;
+use serde_json::{json, Value as Json};
+use tw_coin_entry::error::prelude::*;
+use tw_memory::Data;
+use tw_proto::to_any;
+
+const DEFAULT_INSTANTIATE_JSON_MSG_TYPE: &str = "wasm/MsgInstantiateContract";
+
+#[derive(Clone, Serialize)]
+#[serde(untagged)]
+pub enum InstantiateMsg {
+    /// Either a regular string or a stringified JSON object.
+    String(String),
+    /// JSON object with a type.
+    Json(Json),
+}
+
+impl InstantiateMsg {
+    /// Tries to convert [`InstantiateMsg::String`] to [`InstantiateMsg::Json`], otherwise returns the same object.
+    pub fn try_to_json(&self) -> InstantiateMsg {
+        if let InstantiateMsg::String(s) = self {
+            if let Ok(json) = serde_json::from_str(s) {
+                return InstantiateMsg::Json(json);
+            }
+        }
+        self.clone()
+    }
+
+    /// Creates an [`InstantiateMsg`] from a serializable payload.
+    pub fn json<Payload: Serialize>(payload: Payload) -> SigningResult<InstantiateMsg> {
+        let payload = serde_json::to_value(payload)
+            .tw_err(SigningErrorType::Error_internal)
+            .context("Error serializing message payload to JSON")?;
+        Ok(InstantiateMsg::Json(payload))
+    }
+
+    /// Converts the message to bytes.
+    pub fn to_bytes(&self) -> Data {
+        match self {
+            InstantiateMsg::String(ref s) => s.as_bytes().to_vec(),
+            InstantiateMsg::Json(ref j) => j.to_string().as_bytes().to_vec(),
+        }
+    }
+}
+
+/// This message is used for instantiating a new CosmWasm contract.
+#[derive(Serialize)]
+pub struct WasmInstantiateContractMessage<Address: CosmosAddress> {
+    pub sender: Address,
+    /// (Optional) The address with permission to perform migrations.
+    /// If no admin is provided, this field will be an empty string in the protobuf.
+    pub admin: Option<Address>,
+    /// The Code ID referencing the stored contract code.
+    pub code_id: u64,
+    /// A human-readable label for the contract instance.
+    pub label: String,
+    /// A JSON-encoded initialization message.
+    pub msg: InstantiateMsg,
+    /// A list of coins to be sent along with the instantiation.
+    pub funds: Vec<Coin>,
+}
+
+impl<Address: CosmosAddress> CosmosMessage for WasmInstantiateContractMessage<Address> {
+    fn to_proto(&self) -> SigningResult<ProtobufMessage> {
+        let proto_msg = cosmwasm::wasm::v1::MsgInstantiateContract {
+            sender: self.sender.to_string().into(),
+            admin: self
+                .admin
+                .as_ref()
+                .map_or("".into(), |admin| admin.to_string().into()),
+            code_id: self.code_id,
+            label: self.label.clone().into(),
+            msg: self.msg.to_bytes().into(),
+            // Use "init_funds" here, matching the protobuf definition.
+            init_funds: self.funds.iter().map(build_coin).collect(),
+        };
+        Ok(to_any(&proto_msg))
+    }
+
+    fn to_json(&self) -> SigningResult<JsonMessage> {
+        let value = json!({
+            "sender": self.sender,
+            "admin": self.admin,
+            "code_id": self.code_id,
+            "label": self.label,
+            "msg": self.msg.try_to_json(),
+            "init_funds": self.funds,
+        });
+        Ok(JsonMessage {
+            msg_type: DEFAULT_INSTANTIATE_JSON_MSG_TYPE.to_string(),
+            value,
+        })
+    }
+}

rust/tw_cosmos_sdk/tests/sign_wasm_contract.rs

@@ -7,7 +7,7 @@ use std::borrow::Cow;
 use tw_coin_entry::test_utils::test_context::TestCoinContext;
 use tw_cosmos_sdk::context::StandardCosmosContext;
 use tw_cosmos_sdk::modules::tx_builder::TxBuilder;
-use tw_cosmos_sdk::test_utils::proto_utils::{make_amount, make_fee, make_message};
+use tw_cosmos_sdk::test_utils::proto_utils::{make_amount, make_fee, make_fee_none, make_message};
 use tw_cosmos_sdk::test_utils::sign_utils::{test_sign_json, test_sign_protobuf, TestInput};
 use tw_encoding::base64::{self, STANDARD};
 use tw_encoding::hex::DecodeHex;
@@ -16,6 +16,13 @@ use tw_number::U256;
 use tw_proto::Cosmos::Proto;
 use tw_proto::Cosmos::Proto::mod_Message::OneOfmessage_oneof as MessageEnum;
 
+fn account_593_private_key() -> Cow<'static, [u8]> {
+    "7105512f0c020a1dd759e14b865ec0125f59ac31e34d7a2807a228ed50cb343e"
+        .decode_hex()
+        .unwrap()
+        .into()
+}
+
 fn account_336_private_key() -> Cow<'static, [u8]> {
     "37f0af5bc20adb6832d39368a15492cd1e9e0cc1556d4317a5f75f9ccdf525ee"
         .decode_hex()
@@ -124,6 +131,47 @@ fn test_wasm_execute_generic_with_coins() {
     });
 }
 
+#[test]
+fn test_wasm_instantiate_contract() {
+    let coin = TestCoinContext::default()
+        .with_public_key_type(PublicKeyType::Secp256k1)
+        .with_hrp("thor");
+
+    let execute_msg = r#"{"foo":"bar"}"#;
+
+    let contract = Proto::mod_Message::WasmInstantiateContract {
+        sender: "thor1z53wwe7md6cewz9sqwqzn0aavpaun0gw0exn2r".into(),
+        admin: "thor1z53wwe7md6cewz9sqwqzn0aavpaun0gw0exn2r".into(),
+        code_id: 1,
+        label: "Contract".into(),
+        msg: Cow::Borrowed(execute_msg.as_bytes()),
+        init_funds: vec![],
+        ..Default::default()
+    };
+
+    let input = Proto::SigningInput {
+        account_number: 593,
+        chain_id: "thorchain-1".into(),
+        sequence: 24,
+        fee: Some(make_fee_none(200_000)),
+        private_key: account_593_private_key(),
+        mode: Proto::BroadcastMode::SYNC,
+        messages: vec![make_message(
+            MessageEnum::wasm_instantiate_contract_message(contract),
+        )],
+        ..Default::default()
+    };
+
+    // https://thornode.ninerealms.com/cosmos/tx/v1beta1/txs/45CECF3858D1B4C2D49A48C83082D6F018A1E06CA68B1E76F7FF86D5CEC67255
+    test_sign_protobuf::<StandardCosmosContext>(TestInput {
+        coin: &coin,
+        input: input.clone(),
+        tx: r#"{"mode":"BROADCAST_MODE_SYNC","tx_bytes":"CqQBCqEBCigvY29zbXdhc20ud2FzbS52MS5Nc2dJbnN0YW50aWF0ZUNvbnRyYWN0EnUKK3Rob3IxejUzd3dlN21kNmNld3o5c3F3cXpuMGFhdnBhdW4wZ3cwZXhuMnISK3Rob3IxejUzd3dlN21kNmNld3o5c3F3cXpuMGFhdnBhdW4wZ3cwZXhuMnIYASIIQ29udHJhY3QqDXsiZm9vIjoiYmFyIn0SWApQCkYKHy9jb3Ntb3MuY3J5cHRvLnNlY3AyNTZrMS5QdWJLZXkSIwohA+2Zfjls9CkvX85aQrukFZnM1dluMTFUp8nqcEneMXx3EgQKAggBGBgSBBDAmgwaQBJNYdvq5b6xOY6tZDgJo7ueYCjs4XKPwg3Np10E6T6CLO6W7SsYKh2GiSrwHvzSA5ragedrQ+h9HwaTIGTLmOE="}"#,
+        signature: "124d61dbeae5beb1398ead643809a3bb9e6028ece1728fc20dcda75d04e93e822cee96ed2b182a1d86892af01efcd2039ada81e76b43e87d1f06932064cb98e1",
+        signature_json: r#"[{"pub_key":{"type":"tendermint/PubKeySecp256k1","value":"A+2Zfjls9CkvX85aQrukFZnM1dluMTFUp8nqcEneMXx3"},"signature":"Ek1h2+rlvrE5jq1kOAmju55gKOzhco/CDc2nXQTpPoIs7pbtKxgqHYaJKvAe/NIDmtqB52tD6H0fBpMgZMuY4Q=="}]"#
+    });
+}
+
 /// TerraV2 Transfer
 #[test]
 fn test_wasm_execute_transfer() {

src/proto/Cosmos.proto

@@ -232,6 +232,16 @@ message Message {
         repeated Amount coins = 5;
     }
 
+    // MsgInstantiateContract defines a message for instantiating a new CosmWasm contract.
+    message WasmInstantiateContract {
+        string sender = 1;
+        string admin = 2;
+        uint64 code_id = 3;
+        string label = 4;
+        bytes msg = 5;
+        repeated Amount init_funds = 6;
+    }
+
     message RawJSON {
         string type = 1;
         string value = 2;
@@ -284,7 +294,6 @@ message Message {
         REDELEGATE = 3;
     }
 
-
     // cosmos-sdk/MsgGrant
     message AuthGrant {
         string granter = 1;
@@ -318,8 +327,8 @@ message Message {
 
     // cosmos-sdk/MsgVote defines a message to cast a vote.
     message MsgVote {
-        uint64     proposal_id = 1;
-        string     voter = 2;
+        uint64 proposal_id = 1;
+        string voter = 2;
         VoteOption option = 3;
     }
 
@@ -353,20 +362,21 @@ message Message {
         WasmExecuteContractSend wasm_execute_contract_send_message = 14;
         WasmExecuteContractGeneric wasm_execute_contract_generic = 15;
         SignDirect sign_direct_message = 16;
-        AuthGrant  auth_grant = 17;
+        AuthGrant auth_grant = 17;
         AuthRevoke auth_revoke = 18;
         SetWithdrawAddress set_withdraw_address_message = 19;
         MsgVote msg_vote = 20;
         MsgStrideLiquidStakingStake msg_stride_liquid_staking_stake = 21;
         MsgStrideLiquidStakingRedeem msg_stride_liquid_staking_redeem = 22;
         THORChainDeposit thorchain_deposit_message = 23;
+        WasmInstantiateContract wasm_instantiate_contract_message = 24;
     }
 }
 
 // Options for transaction encoding: JSON (Amino, older) or Protobuf.
 enum SigningMode {
-    JSON = 0;        // JSON format, Pre-Stargate
-    Protobuf = 1;    // Protobuf-serialized (binary), Stargate
+    JSON = 0;     // JSON format, Pre-Stargate
+    Protobuf = 1; // Protobuf-serialized (binary), Stargate
 }
 
 enum TxHasher {