Making DenomUnit public so all Metadata fields can be set

contracts/tokenfactory/src/contract.rs

@@ -5,10 +5,11 @@ use cosmwasm_std::{
 };
 use cw2::set_contract_version;
 
+use token_bindings::{Metadata, TokenFactoryMsg, TokenFactoryQuery, TokenMsg, TokenQuerier};
+
 use crate::error::TokenFactoryError;
 use crate::msg::{ExecuteMsg, GetDenomResponse, InstantiateMsg, QueryMsg};
 use crate::state::{State, STATE};
-use token_bindings::{TokenFactoryMsg, TokenFactoryQuery, TokenMsg, TokenQuerier};
 
 // version info for migration info
 const CONTRACT_NAME: &str = "crates.io:tokenfactory-demo";
@@ -40,7 +41,7 @@ pub fn execute(
     msg: ExecuteMsg,
 ) -> Result<Response<TokenFactoryMsg>, TokenFactoryError> {
     match msg {
-        ExecuteMsg::CreateDenom { subdenom } => create_denom(subdenom),
+        ExecuteMsg::CreateDenom { subdenom, metadata } => create_denom(subdenom, metadata),
         ExecuteMsg::ChangeAdmin {
             denom,
             new_admin_address,
@@ -58,15 +59,15 @@ pub fn execute(
     }
 }
 
-pub fn create_denom(subdenom: String) -> Result<Response<TokenFactoryMsg>, TokenFactoryError> {
-    if subdenom.eq("") {
+pub fn create_denom(
+    subdenom: String,
+    metadata: Option<Metadata>,
+) -> Result<Response<TokenFactoryMsg>, TokenFactoryError> {
+    if subdenom.is_empty() {
         return Err(TokenFactoryError::InvalidSubdenom { subdenom });
     }
 
-    let create_denom_msg = TokenMsg::CreateDenom {
-        subdenom,
-        metadata: None,
-    };
+    let create_denom_msg = TokenMsg::CreateDenom { subdenom, metadata };
 
     let res = Response::new()
         .add_attribute("method", "create_denom")
@@ -212,18 +213,21 @@ fn validate_denom(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::marker::PhantomData;
+
     use cosmwasm_std::testing::{
         mock_env, mock_info, MockApi, MockQuerier, MockStorage, MOCK_CONTRACT_ADDR,
     };
     use cosmwasm_std::{
         coins, from_binary, Attribute, ContractResult, CosmosMsg, OwnedDeps, Querier, StdError,
         SystemError, SystemResult,
     };
-    use std::marker::PhantomData;
-    use token_bindings::TokenQuery;
+
+    use token_bindings::{DenomUnit, TokenQuery};
     use token_bindings_test::TokenFactoryApp;
 
+    use super::*;
+
     const DENOM_NAME: &str = "mydenom";
     const DENOM_PREFIX: &str = "factory";
 
@@ -305,15 +309,40 @@ mod tests {
 
         let subdenom: String = String::from(DENOM_NAME);
 
-        let msg = ExecuteMsg::CreateDenom { subdenom };
+        let msg = ExecuteMsg::CreateDenom {
+            subdenom,
+            metadata: Some(Metadata {
+                description: Some("description".to_string()),
+                denom_units: vec![DenomUnit {
+                    denom: DENOM_NAME.to_string(),
+                    exponent: 6,
+                    aliases: vec![],
+                }],
+                base: Some(format!("{}{}", "u", DENOM_NAME)),
+                display: Some(DENOM_NAME.to_string()),
+                name: Some(format!("{} {}", DENOM_NAME, "Token")),
+                symbol: Some(DENOM_NAME.to_string()),
+            }),
+        };
         let info = mock_info("creator", &coins(2, "token"));
         let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
 
         assert_eq!(1, res.messages.len());
 
         let expected_message = CosmosMsg::from(TokenMsg::CreateDenom {
             subdenom: String::from(DENOM_NAME),
-            metadata: None,
+            metadata: Some(Metadata {
+                description: Some("description".to_string()),
+                denom_units: vec![DenomUnit {
+                    denom: DENOM_NAME.to_string(),
+                    exponent: 6,
+                    aliases: vec![],
+                }],
+                base: Some(format!("{}{}", "u", DENOM_NAME)),
+                display: Some(DENOM_NAME.to_string()),
+                name: Some(format!("{} {}", DENOM_NAME, "Token")),
+                symbol: Some(DENOM_NAME.to_string()),
+            }),
         });
         let actual_message = res.messages.get(0).unwrap();
         assert_eq!(expected_message, actual_message.msg);
@@ -333,7 +362,10 @@ mod tests {
 
         let subdenom: String = String::from("");
 
-        let msg = ExecuteMsg::CreateDenom { subdenom };
+        let msg = ExecuteMsg::CreateDenom {
+            subdenom,
+            metadata: None,
+        };
         let info = mock_info("creator", &coins(2, "token"));
         let err = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
         assert_eq!(

contracts/tokenfactory/src/msg.rs

@@ -1,5 +1,6 @@
 use cosmwasm_schema::{cw_serde, QueryResponses};
 use cosmwasm_std::Uint128;
+use token_bindings::Metadata;
 
 #[cw_serde]
 pub struct InstantiateMsg {}
@@ -8,6 +9,7 @@ pub struct InstantiateMsg {}
 pub enum ExecuteMsg {
     CreateDenom {
         subdenom: String,
+        metadata: Option<Metadata>,
     },
     ChangeAdmin {
         denom: String,

packages/bindings/src/lib.rs

@@ -9,7 +9,7 @@ pub use query::{
     AdminResponse, DenomsByCreatorResponse, FullDenomResponse, MetadataResponse, ParamsResponse,
     TokenFactoryQuery, TokenQuery,
 };
-pub use types::{Metadata, Params};
+pub use types::{DenomUnit, Metadata, Params};
 
 // This is a signal, such that any contract that imports these helpers will only run on
 // blockchains that support token_factory feature

packages/bindings/src/types.rs

@@ -28,9 +28,9 @@ pub struct DenomUnit {
     /// 1 denom = 1^exponent base_denom
     /// (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with
     /// exponent = 6, thus: 1 atom = 10^6 uatom).
-    exponent: u32,
+    pub exponent: u32,
     /// aliases is a list of string aliases for the given denom
-    aliases: Vec<String>,
+    pub aliases: Vec<String>,
 }
 
 /// This maps to osmosis.tokenfactory.v1beta1.Params protobuf struct