name-service: Migrate to cosmwasm v0.11.0

nameservice/Cargo.toml

@@ -38,12 +38,12 @@ cranelift = ["cosmwasm-vm/default-cranelift"]
 singlepass = ["cosmwasm-vm/default-singlepass"]
 
 [dependencies]
-cosmwasm-std = "0.11.0-alpha3"
-cosmwasm-storage = "0.11.0-alpha3"
+cosmwasm-std = "0.11.0"
+cosmwasm-storage = "0.11.0"
 thiserror = { version = "1.0.20" }
 schemars = "0.7"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }
 
 [dev-dependencies]
-cosmwasm-vm = { version = "0.11.0-alpha3", default-features = false }
-cosmwasm-schema = "0.11.0-alpha3"
+cosmwasm-vm = { version = "0.11.0", default-features = false }
+cosmwasm-schema = "0.11.0"

nameservice/src/contract.rs

@@ -1,6 +1,6 @@
 use cosmwasm_std::{
     to_binary, Api, Binary, Env, Extern, HandleResponse, HumanAddr, InitResponse, InitResult,
-    Querier, StdResult, Storage,
+    MessageInfo, Querier, StdResult, Storage,
 };
 
 use crate::coin_helpers::assert_sent_sufficient_coin;
@@ -14,6 +14,7 @@ const MAX_NAME_LENGTH: u64 = 64;
 pub fn init<S: Storage, A: Api, Q: Querier>(
     deps: &mut Extern<S, A, Q>,
     _env: Env,
+    _info: MessageInfo,
     msg: InitMsg,
 ) -> InitResult {
     let config_state = Config {
@@ -29,27 +30,29 @@ pub fn init<S: Storage, A: Api, Q: Querier>(
 pub fn handle<S: Storage, A: Api, Q: Querier>(
     deps: &mut Extern<S, A, Q>,
     env: Env,
+    info: MessageInfo,
     msg: HandleMsg,
 ) -> Result<HandleResponse, ContractError> {
     match msg {
-        HandleMsg::Register { name } => try_register(deps, env, name),
-        HandleMsg::Transfer { name, to } => try_transfer(deps, env, name, to),
+        HandleMsg::Register { name } => try_register(deps, env, info, name),
+        HandleMsg::Transfer { name, to } => try_transfer(deps, env, info, name, to),
     }
 }
 
 pub fn try_register<S: Storage, A: Api, Q: Querier>(
     deps: &mut Extern<S, A, Q>,
-    env: Env,
+    _env: Env,
+    info: MessageInfo,
     name: String,
 ) -> Result<HandleResponse, ContractError> {
     // we only need to check here - at point of registration
     validate_name(&name)?;
     let config_state = config(&mut deps.storage).load()?;
-    assert_sent_sufficient_coin(&env.message.sent_funds, config_state.purchase_price)?;
+    assert_sent_sufficient_coin(&info.sent_funds, config_state.purchase_price)?;
 
     let key = name.as_bytes();
     let record = NameRecord {
-        owner: deps.api.canonical_address(&env.message.sender)?,
+        owner: deps.api.canonical_address(&info.sender)?,
     };
 
     if (resolver(&mut deps.storage).may_load(key)?).is_some() {
@@ -65,43 +68,46 @@ pub fn try_register<S: Storage, A: Api, Q: Querier>(
 
 pub fn try_transfer<S: Storage, A: Api, Q: Querier>(
     deps: &mut Extern<S, A, Q>,
-    env: Env,
+    _env: Env,
+    info: MessageInfo,
     name: String,
     to: HumanAddr,
 ) -> Result<HandleResponse, ContractError> {
     let api = deps.api;
     let config_state = config(&mut deps.storage).load()?;
-    assert_sent_sufficient_coin(&env.message.sent_funds, config_state.transfer_price)?;
+    assert_sent_sufficient_coin(&info.sent_funds, config_state.transfer_price)?;
 
     let new_owner = deps.api.canonical_address(&to)?;
-
-    resolver(&mut deps.storage).update(name.clone().as_bytes(), |record| {
+    let key = name.as_bytes();
+    resolver(&mut deps.storage).update(key, |record| {
         if let Some(mut record) = record {
-            if api.canonical_address(&env.message.sender)? != record.owner {
+            if api.canonical_address(&info.sender)? != record.owner {
                 return Err(ContractError::Unauthorized {});
             }
 
             record.owner = new_owner.clone();
             Ok(record)
         } else {
-            Err(ContractError::NameNotExists { name })
+            Err(ContractError::NameNotExists { name: name.clone() })
         }
     })?;
     Ok(HandleResponse::default())
 }
 
 pub fn query<S: Storage, A: Api, Q: Querier>(
     deps: &Extern<S, A, Q>,
+    env: Env,
     msg: QueryMsg,
 ) -> StdResult<Binary> {
     match msg {
-        QueryMsg::ResolveRecord { name } => query_resolver(deps, name),
+        QueryMsg::ResolveRecord { name } => query_resolver(deps, env, name),
         QueryMsg::Config {} => to_binary(&config_read(&deps.storage).load()?),
     }
 }
 
 fn query_resolver<S: Storage, A: Api, Q: Querier>(
     deps: &Extern<S, A, Q>,
+    _env: Env,
     name: String,
 ) -> StdResult<Binary> {
     let key = name.as_bytes();