Merge pull request #2099 from CosmWasm/chipshort/convert-response

Add custom message conversion

Author: chipshort

CHANGELOG.md

@@ -21,13 +21,16 @@ and this project adheres to
 - cosmwasm-std: Implement `&T + T` and `&T op &T` for `Uint64`, `Uint128`,
   `Uint256` and `Uint512`; improve panic message for `Uint64::add` and
   `Uint512::add` ([#2092])
+- cosmwasm-std: Add `{CosmosMsg,SubMsg,Response}::change_custom` to change the
+  custom message type ([#2099])
 
 [#1983]: https://github.com/CosmWasm/cosmwasm/pull/1983
 [#2057]: https://github.com/CosmWasm/cosmwasm/pull/2057
 [#2058]: https://github.com/CosmWasm/cosmwasm/pull/2058
 [#2068]: https://github.com/CosmWasm/cosmwasm/pull/2068
 [#2075]: https://github.com/CosmWasm/cosmwasm/pull/2075
 [#2092]: https://github.com/CosmWasm/cosmwasm/pull/2092
+[#2099]: https://github.com/CosmWasm/cosmwasm/pull/2099
 
 ### Changed
 

packages/std/src/results/cosmos_msg.rs

@@ -58,6 +58,32 @@ pub enum CosmosMsg<T = Empty> {
     Gov(GovMsg),
 }
 
+impl<T> CosmosMsg<T> {
+    /// Convert this this [`CosmosMsg<T>`] to a [`CosmosMsg<U>`] with a different custom message type.
+    /// This allows easier interactions between code written for a specific chain and
+    /// code written for multiple chains.
+    /// If this is the [`CosmosMsg::Custom`] variant, the function returns `None`.
+    pub fn change_custom<U>(self) -> Option<CosmosMsg<U>> {
+        Some(match self {
+            CosmosMsg::Bank(msg) => CosmosMsg::Bank(msg),
+            CosmosMsg::Custom(_) => return None,
+            #[cfg(feature = "staking")]
+            CosmosMsg::Staking(msg) => CosmosMsg::Staking(msg),
+            #[cfg(feature = "staking")]
+            CosmosMsg::Distribution(msg) => CosmosMsg::Distribution(msg),
+            #[cfg(feature = "stargate")]
+            CosmosMsg::Stargate { type_url, value } => CosmosMsg::Stargate { type_url, value },
+            #[cfg(feature = "cosmwasm_2_0")]
+            CosmosMsg::Any(msg) => CosmosMsg::Any(msg),
+            #[cfg(feature = "stargate")]
+            CosmosMsg::Ibc(msg) => CosmosMsg::Ibc(msg),
+            CosmosMsg::Wasm(msg) => CosmosMsg::Wasm(msg),
+            #[cfg(feature = "stargate")]
+            CosmosMsg::Gov(msg) => CosmosMsg::Gov(msg),
+        })
+    }
+}
+
 /// The message types of the bank module.
 ///
 /// See https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/bank/v1beta1/tx.proto
@@ -664,4 +690,31 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn change_custom_works() {
+        #[derive(Debug, PartialEq, Eq, Clone)]
+        struct Custom {
+            _a: i32,
+        }
+        let send = BankMsg::Send {
+            to_address: "you".to_string(),
+            amount: coins(1015, "earth"),
+        };
+        // Custom to Empty
+        let msg: CosmosMsg<Custom> = send.clone().into();
+        let msg2: CosmosMsg<Empty> = msg.change_custom().unwrap();
+        assert_eq!(msg2, CosmosMsg::Bank(send.clone()));
+        let custom = CosmosMsg::Custom(Custom { _a: 5 });
+        let converted = custom.change_custom::<Empty>();
+        assert_eq!(converted, None);
+
+        // Empty to Custom
+        let msg: CosmosMsg<Empty> = send.clone().into();
+        let msg2: CosmosMsg<Custom> = msg.change_custom().unwrap();
+        assert_eq!(msg2, CosmosMsg::Bank(send));
+        let empty = CosmosMsg::Custom(Empty {});
+        let converted = empty.change_custom::<Custom>();
+        assert_eq!(converted, None);
+    }
 }

packages/std/src/results/response.rs

@@ -232,6 +232,23 @@ impl<T> Response<T> {
         self.data = Some(data.into());
         self
     }
+
+    /// Convert this [`Response<T>`] to a [`Response<U>`] with a different custom message type.
+    /// This allows easier interactions between code written for a specific chain and
+    /// code written for multiple chains.
+    /// If this contains a [`CosmosMsg::Custom`] submessage, the function returns `None`.
+    pub fn change_custom<U>(self) -> Option<Response<U>> {
+        Some(Response {
+            messages: self
+                .messages
+                .into_iter()
+                .map(|msg| msg.change_custom())
+                .collect::<Option<Vec<_>>>()?,
+            attributes: self.attributes,
+            events: self.events,
+            data: self.data,
+        })
+    }
 }
 
 #[cfg(test)]
@@ -370,4 +387,38 @@ mod tests {
         let expected = Response::<Empty>::new().add_events(events);
         assert_eq!(expected, actual);
     }
+
+    #[test]
+    fn change_custom_works() {
+        let response: Response<Empty> = Response {
+            messages: vec![SubMsg::new(BankMsg::Send {
+                to_address: "address".to_string(),
+                amount: coins(123, "earth"),
+            })],
+            attributes: vec![Attribute::new("foo", "bar")],
+            events: vec![Event::new("our_event").add_attribute("msg", "hello")],
+            data: None,
+        };
+        let converted_resp: Response<String> = response.clone().change_custom().unwrap();
+        assert_eq!(
+            converted_resp.messages,
+            vec![SubMsg::new(BankMsg::Send {
+                to_address: "address".to_string(),
+                amount: coins(123, "earth"),
+            })]
+        );
+        assert_eq!(converted_resp.attributes, response.attributes);
+        assert_eq!(converted_resp.events, response.events);
+        assert_eq!(converted_resp.data, response.data);
+
+        // response with custom message
+        let response = Response {
+            messages: vec![SubMsg::new(CosmosMsg::Custom(Empty {}))],
+            attributes: vec![Attribute::new("foo", "bar")],
+            events: vec![Event::new("our_event").add_attribute("msg", "hello")],
+            data: None,
+        };
+
+        assert_eq!(response.change_custom::<String>(), None);
+    }
 }

packages/std/src/results/submessages.rs

@@ -148,6 +148,20 @@ impl<T> SubMsg<T> {
             gas_limit: None,
         }
     }
+
+    /// Convert this [`SubMsg<T>`] to a [`SubMsg<U>`] with a different generic type.
+    /// This allows easier interactions between code written for a specific chain and
+    /// code written for multiple chains.
+    /// If this is a [`CosmosMsg::Custom`] submessage, the function returns `None`.
+    pub fn change_custom<U>(self) -> Option<SubMsg<U>> {
+        Some(SubMsg {
+            id: self.id,
+            payload: self.payload,
+            msg: self.msg.change_custom::<U>()?,
+            gas_limit: self.gas_limit,
+            reply_on: self.reply_on,
+        })
+    }
 }
 
 /// The result object returned to `reply`. We always get the ID from the submessage