Update cosmwasm-std

packages/cw0/src/pagination.rs

@@ -1,21 +1,18 @@
-use cosmwasm_std::{Api, CanonicalAddr, HumanAddr, StdResult};
+use cosmwasm_std::{Addr, Api, CanonicalAddr, StdResult};
 
 // this is used for pagination. Maybe we move it into the std lib one day?
-pub fn maybe_canonical(
-    api: &dyn Api,
-    human: Option<HumanAddr>,
-) -> StdResult<Option<CanonicalAddr>> {
-    human.map(|x| api.canonical_address(&x)).transpose()
+pub fn maybe_canonical(api: &dyn Api, human: Option<Addr>) -> StdResult<Option<CanonicalAddr>> {
+    human.map(|x| api.addr_canonicalize(x.as_ref())).transpose()
 }
 
 // this will set the first key after the provided key, by appending a 0 byte
 pub fn calc_range_start_human(
     api: &dyn Api,
-    start_after: Option<HumanAddr>,
+    start_after: Option<Addr>,
 ) -> StdResult<Option<Vec<u8>>> {
     match start_after {
         Some(human) => {
-            let mut v: Vec<u8> = api.canonical_address(&human)?.0.into();
+            let mut v: Vec<u8> = api.addr_canonicalize(human.as_ref())?.0.into();
             v.push(0);
             Ok(Some(v))
         }
@@ -24,13 +21,10 @@ pub fn calc_range_start_human(
 }
 
 // set the end to the canonicalized format (used for Order::Descending)
-pub fn calc_range_end_human(
-    api: &dyn Api,
-    end_before: Option<HumanAddr>,
-) -> StdResult<Option<Vec<u8>>> {
+pub fn calc_range_end_human(api: &dyn Api, end_before: Option<Addr>) -> StdResult<Option<Vec<u8>>> {
     match end_before {
         Some(human) => {
-            let v: Vec<u8> = api.canonical_address(&human)?.0.into();
+            let v: Vec<u8> = api.addr_canonicalize(human.as_ref())?.into();
             Ok(Some(v))
         }
         None => Ok(None),

packages/cw1/src/helpers.rs

@@ -1,32 +1,32 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use cosmwasm_std::{to_binary, Api, CanonicalAddr, CosmosMsg, HumanAddr, StdResult, WasmMsg};
+use cosmwasm_std::{to_binary, Addr, Api, CanonicalAddr, CosmosMsg, StdResult, WasmMsg};
 
 use crate::msg::Cw1ExecuteMsg;
 
-/// Cw1Contract is a wrapper around HumanAddr that provides a lot of helpers
+/// Cw1Contract is a wrapper around Addr that provides a lot of helpers
 /// for working with this.
 ///
 /// If you wish to persist this, convert to Cw1CanonicalContract via .canonical()
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
-pub struct Cw1Contract(pub HumanAddr);
+pub struct Cw1Contract(pub Addr);
 
 impl Cw1Contract {
-    pub fn addr(&self) -> HumanAddr {
+    pub fn addr(&self) -> Addr {
         self.0.clone()
     }
 
     /// Convert this address to a form fit for storage
     pub fn canonical<A: Api>(&self, api: &A) -> StdResult<Cw1CanonicalContract> {
-        let canon = api.canonical_address(&self.0)?;
+        let canon = api.addr_canonicalize(self.0.as_ref())?;
         Ok(Cw1CanonicalContract(canon))
     }
 
     pub fn execute<T: Into<Vec<CosmosMsg>>>(&self, msgs: T) -> StdResult<CosmosMsg> {
         let msg = Cw1ExecuteMsg::Execute { msgs: msgs.into() };
         Ok(WasmMsg::Execute {
-            contract_addr: self.addr(),
+            contract_addr: self.addr().into(),
             msg: to_binary(&msg)?,
             send: vec![],
         }
@@ -42,7 +42,7 @@ pub struct Cw1CanonicalContract(pub CanonicalAddr);
 impl Cw1CanonicalContract {
     /// Convert this address to a form fit for usage in messages and queries
     pub fn human<A: Api>(&self, api: &A) -> StdResult<Cw1Contract> {
-        let human = api.human_address(&self.0)?;
+        let human = api.addr_humanize(&self.0)?;
         Ok(Cw1Contract(human))
     }
 }

packages/cw1/src/query.rs

@@ -2,7 +2,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-use cosmwasm_std::{CosmosMsg, Empty, HumanAddr};
+use cosmwasm_std::{CosmosMsg, Empty, Addr};
 
 #[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
 #[serde(rename_all = "snake_case")]
@@ -14,7 +14,7 @@ where
     /// If CanExecute returns true then a call to `Execute` with the same message,
     /// from the given sender, before any further state changes, should also succeed.
     CanExecute {
-        sender: HumanAddr,
+        sender: Addr,
         msg: CosmosMsg<T>,
     },
 }

packages/cw2/src/lib.rs

@@ -1,9 +1,7 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use cosmwasm_std::{
-    HumanAddr, Querier, QuerierWrapper, QueryRequest, StdResult, Storage, WasmQuery,
-};
+use cosmwasm_std::{Querier, QuerierWrapper, QueryRequest, StdResult, Storage, WasmQuery};
 use cw_storage_plus::Item;
 
 pub const CONTRACT: Item<ContractVersion> = Item::new("contract_info");
@@ -44,7 +42,7 @@ pub fn set_contract_version<T: Into<String>, U: Into<String>>(
 /// if the other contract exists and claims to be a cw20-base contract for example.
 /// (Note: you usually want to require *interfaces* not *implementations* of the
 /// contracts you compose with, so be careful of overuse)
-pub fn query_contract_info<Q: Querier, T: Into<HumanAddr>>(
+pub fn query_contract_info<Q: Querier, T: Into<String>>(
     querier: &Q,
     contract_addr: T,
 ) -> StdResult<ContractVersion> {

packages/cw3/src/helpers.rs

@@ -1,29 +1,29 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use cosmwasm_std::{to_binary, CosmosMsg, HumanAddr, StdResult, WasmMsg};
+use cosmwasm_std::{to_binary, Addr, CosmosMsg, StdResult, WasmMsg};
 
 use crate::msg::{Cw3ExecuteMsg, Vote};
 use cw0::Expiration;
 
-/// Cw3Contract is a wrapper around HumanAddr that provides a lot of helpers
+/// Cw3Contract is a wrapper around Addr that provides a lot of helpers
 /// for working with this.
 ///
 /// If you wish to persist this, convert to Cw3CanonicalContract via .canonical()
 ///
 /// FIXME: Cw3Contract currently only supports CosmosMsg<Empty>. When we actually
 /// use this in some consuming code, we should make it generic over CosmosMsg<T>.
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
-pub struct Cw3Contract(pub HumanAddr);
+pub struct Cw3Contract(pub Addr);
 
 impl Cw3Contract {
-    pub fn addr(&self) -> HumanAddr {
+    pub fn addr(&self) -> Addr {
         self.0.clone()
     }
 
     pub fn encode_msg(&self, msg: Cw3ExecuteMsg) -> StdResult<CosmosMsg> {
         Ok(WasmMsg::Execute {
-            contract_addr: self.addr(),
+            contract_addr: self.addr().into(),
             msg: to_binary(&msg)?,
             send: vec![],
         }

packages/cw3/src/query.rs

@@ -2,7 +2,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-use cosmwasm_std::{CosmosMsg, Decimal, Empty, HumanAddr};
+use cosmwasm_std::{CosmosMsg, Decimal, Empty, Addr};
 use cw0::Expiration;
 
 use crate::msg::Vote;
@@ -31,20 +31,20 @@ pub enum Cw3QueryMsg {
     /// Query the vote made by the given voter on `proposal_id`. This should
     /// return an error if there is no such proposal. It will return a None value
     /// if the proposal exists but the voter did not vote. Returns VoteResponse
-    Vote { proposal_id: u64, voter: HumanAddr },
+    Vote { proposal_id: u64, voter: Addr },
     /// Iterate (with pagination) over all votes for this proposal. The ordering is arbitrary,
-    /// unlikely to be sorted by HumanAddr. But ordering is consistent and pagination from the end
+    /// unlikely to be sorted by Addr. But ordering is consistent and pagination from the end
     /// of each page will cover all votes for the proposal. Returns VoteListResponse
     ListVotes {
         proposal_id: u64,
-        start_after: Option<HumanAddr>,
+        start_after: Option<Addr>,
         limit: Option<u32>,
     },
     /// Voter extension: Returns VoterResponse
-    Voter { address: HumanAddr },
+    Voter { address: Addr },
     /// ListVoters extension: Returns VoterListResponse
     ListVoters {
-        start_after: Option<HumanAddr>,
+        start_after: Option<Addr>,
         limit: Option<u32>,
     },
 }
@@ -168,7 +168,7 @@ pub struct VoteListResponse {
 /// the address of the voter who submitted it
 #[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
 pub struct VoteInfo {
-    pub voter: HumanAddr,
+    pub voter: Addr,
     pub vote: Vote,
     pub weight: u64,
 }
@@ -190,6 +190,6 @@ pub struct VoterListResponse {
 
 #[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
 pub struct VoterDetail {
-    pub addr: HumanAddr,
+    pub addr: Addr,
     pub weight: u64,
 }

packages/cw4/src/helpers.rs

@@ -2,8 +2,8 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use cosmwasm_std::{
-    from_slice, to_binary, to_vec, Binary, CanonicalAddr, ContractResult, CosmosMsg, Empty,
-    HumanAddr, QuerierWrapper, QueryRequest, StdError, StdResult, SystemResult, WasmMsg, WasmQuery,
+    from_slice, to_binary, to_vec, Addr, Binary, CanonicalAddr, ContractResult, CosmosMsg, Empty,
+    QuerierWrapper, QueryRequest, StdError, StdResult, SystemResult, WasmMsg, WasmQuery,
 };
 
 use crate::msg::Cw4ExecuteMsg;
@@ -12,67 +12,64 @@ use crate::{
     member_key, AdminResponse, Cw4QueryMsg, Member, MemberListResponse, MemberResponse, TOTAL_KEY,
 };
 
-/// Cw4Contract is a wrapper around HumanAddr that provides a lot of helpers
+/// Cw4Contract is a wrapper around Addr that provides a lot of helpers
 /// for working with cw4 contracts
 ///
 /// If you wish to persist this, convert to Cw4CanonicalContract via .canonical()
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
-pub struct Cw4Contract(pub HumanAddr);
+pub struct Cw4Contract(pub Addr);
 
 impl Cw4Contract {
-    pub fn new(addr: HumanAddr) -> Self {
+    pub fn new(addr: Addr) -> Self {
         Cw4Contract(addr)
     }
 
-    pub fn addr(&self) -> HumanAddr {
+    pub fn addr(&self) -> Addr {
         self.0.clone()
     }
 
     fn encode_msg(&self, msg: Cw4ExecuteMsg) -> StdResult<CosmosMsg> {
         Ok(WasmMsg::Execute {
-            contract_addr: self.addr(),
+            contract_addr: self.addr().into(),
             msg: to_binary(&msg)?,
             send: vec![],
         }
         .into())
     }
 
-    pub fn add_hook(&self, addr: HumanAddr) -> StdResult<CosmosMsg> {
+    pub fn add_hook(&self, addr: Addr) -> StdResult<CosmosMsg> {
         let msg = Cw4ExecuteMsg::AddHook { addr };
         self.encode_msg(msg)
     }
 
-    pub fn remove_hook(&self, addr: HumanAddr) -> StdResult<CosmosMsg> {
+    pub fn remove_hook(&self, addr: Addr) -> StdResult<CosmosMsg> {
         let msg = Cw4ExecuteMsg::AddHook { addr };
         self.encode_msg(msg)
     }
 
-    pub fn update_admin<T: Into<HumanAddr>>(
-        &self,
-        admin: Option<HumanAddr>,
-    ) -> StdResult<CosmosMsg> {
+    pub fn update_admin<T: Into<Addr>>(&self, admin: Option<Addr>) -> StdResult<CosmosMsg> {
         let msg = Cw4ExecuteMsg::UpdateAdmin { admin };
         self.encode_msg(msg)
     }
 
     fn encode_smart_query(&self, msg: Cw4QueryMsg) -> StdResult<QueryRequest<Empty>> {
         Ok(WasmQuery::Smart {
-            contract_addr: self.addr(),
+            contract_addr: self.addr().into(),
             msg: to_binary(&msg)?,
         }
         .into())
     }
 
     fn encode_raw_query<T: Into<Binary>>(&self, key: T) -> QueryRequest<Empty> {
         WasmQuery::Raw {
-            contract_addr: self.addr(),
+            contract_addr: self.addr().into(),
             key: key.into(),
         }
         .into()
     }
 
     /// Show the hooks
-    pub fn hooks(&self, querier: &QuerierWrapper) -> StdResult<Vec<HumanAddr>> {
+    pub fn hooks(&self, querier: &QuerierWrapper) -> StdResult<Vec<Addr>> {
         let query = self.encode_smart_query(Cw4QueryMsg::Hooks {})?;
         let res: HooksResponse = querier.query(&query)?;
         Ok(res.hooks)
@@ -120,7 +117,7 @@ impl Cw4Contract {
     pub fn member_at_height(
         &self,
         querier: &QuerierWrapper,
-        member: HumanAddr,
+        member: Addr,
         height: u64,
     ) -> StdResult<Option<u64>> {
         let query = self.encode_smart_query(Cw4QueryMsg::Member {
@@ -134,7 +131,7 @@ impl Cw4Contract {
     pub fn list_members(
         &self,
         querier: &QuerierWrapper,
-        start_after: Option<HumanAddr>,
+        start_after: Option<Addr>,
         limit: Option<u32>,
     ) -> StdResult<Vec<Member>> {
         let query = self.encode_smart_query(Cw4QueryMsg::ListMembers { start_after, limit })?;
@@ -143,7 +140,7 @@ impl Cw4Contract {
     }
 
     /// Read the admin
-    pub fn admin(&self, querier: &QuerierWrapper) -> StdResult<Option<HumanAddr>> {
+    pub fn admin(&self, querier: &QuerierWrapper) -> StdResult<Option<Addr>> {
         let query = self.encode_smart_query(Cw4QueryMsg::Admin {})?;
         let res: AdminResponse = querier.query(&query)?;
         Ok(res.admin)

packages/cw4/src/hook.rs

@@ -1,7 +1,7 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use cosmwasm_std::{to_binary, Binary, CosmosMsg, HumanAddr, StdResult, WasmMsg};
+use cosmwasm_std::{to_binary, Addr, Binary, CosmosMsg, StdResult, WasmMsg};
 
 /// MemberDiff shows the old and new states for a given cw4 member
 /// They cannot both be None.
@@ -10,17 +10,13 @@ use cosmwasm_std::{to_binary, Binary, CosmosMsg, HumanAddr, StdResult, WasmMsg};
 /// old = Some, new = None -> Delete
 #[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
 pub struct MemberDiff {
-    pub key: HumanAddr,
+    pub key: Addr,
     pub old: Option<u64>,
     pub new: Option<u64>,
 }
 
 impl MemberDiff {
-    pub fn new<T: Into<HumanAddr>>(
-        addr: T,
-        old_weight: Option<u64>,
-        new_weight: Option<u64>,
-    ) -> Self {
+    pub fn new<T: Into<Addr>>(addr: T, old_weight: Option<u64>, new_weight: Option<u64>) -> Self {
         MemberDiff {
             key: addr.into(),
             old: old_weight,
@@ -53,10 +49,10 @@ impl MemberChangedHookMsg {
     }
 
     /// creates a cosmos_msg sending this struct to the named contract
-    pub fn into_cosmos_msg(self, contract_addr: HumanAddr) -> StdResult<CosmosMsg> {
+    pub fn into_cosmos_msg(self, contract_addr: Addr) -> StdResult<CosmosMsg> {
         let msg = self.into_binary()?;
         let execute = WasmMsg::Execute {
-            contract_addr,
+            contract_addr: contract_addr.into(),
             msg,
             send: vec![],
         };

packages/cw4/src/msg.rs

@@ -1,15 +1,15 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use cosmwasm_std::HumanAddr;
+use cosmwasm_std::Addr;
 
 #[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
 #[serde(rename_all = "snake_case")]
 pub enum Cw4ExecuteMsg {
     /// Change the admin
-    UpdateAdmin { admin: Option<HumanAddr> },
+    UpdateAdmin { admin: Option<Addr> },
     /// Add a new hook to be informed of all membership changes. Must be called by Admin
-    AddHook { addr: HumanAddr },
+    AddHook { addr: Addr },
     /// Remove a hook. Must be called by Admin
-    RemoveHook { addr: HumanAddr },
+    RemoveHook { addr: Addr },
 }