Make Addr::unchecked a const fn

contracts/hackatom/src/contract.rs

@@ -92,7 +92,7 @@ fn do_release(deps: DepsMut, env: Env, info: MessageInfo) -> Result<Response, Ha
 
         let mut resp = Response::new();
         resp.add_attribute("action", "release");
-        resp.add_attribute("destination", to_addr.clone());
+        resp.add_attribute("destination", to_addr);
         resp.add_message(BankMsg::Send {
             to_address: to_addr.into(),
             amount: balance,
@@ -496,9 +496,9 @@ mod tests {
         assert_eq!(
             state,
             State {
-                verifier: Addr::unchecked(verifier),
-                beneficiary: Addr::unchecked(beneficiary),
-                funder: Addr::unchecked(creator),
+                verifier: Addr::unchecked(&verifier),
+                beneficiary: Addr::unchecked(&beneficiary),
+                funder: Addr::unchecked(&creator),
             }
         );
     }
@@ -563,7 +563,7 @@ mod tests {
         let bin_contract: &[u8] = b"my-contract";
 
         // return the unhashed value here
-        let no_work_query = query_recurse(deps.as_ref(), 0, 0, contract.clone()).unwrap();
+        let no_work_query = query_recurse(deps.as_ref(), 0, 0, contract).unwrap();
         assert_eq!(no_work_query.hashed, Binary::from(bin_contract));
 
         // let's see if 5 hashes are done right

contracts/reflect/src/contract.rs

@@ -17,9 +17,7 @@ pub fn instantiate(
     info: MessageInfo,
     msg: InstantiateMsg,
 ) -> StdResult<Response<CustomMsg>> {
-    let state = State {
-        owner: info.sender.clone(),
-    };
+    let state = State { owner: info.sender };
     config(deps.storage).save(&state)?;
 
     let mut resp = Response::new();

contracts/reflect/src/testing.rs

@@ -9,7 +9,7 @@ pub fn mock_dependencies_with_custom_querier(
     contract_balance: &[Coin],
 ) -> OwnedDeps<MockStorage, MockApi, MockQuerier<SpecialQuery>> {
     let custom_querier: MockQuerier<SpecialQuery> =
-        MockQuerier::new(&[(MOCK_CONTRACT_ADDR, contract_balance)])
+        MockQuerier::new(&[(MOCK_CONTRACT_ADDR.as_str(), contract_balance)])
             .with_custom_handler(|query| SystemResult::Ok(custom_query_execute(&query)));
     OwnedDeps {
         storage: MockStorage::default(),

contracts/reflect/tests/integration.rs

@@ -46,7 +46,7 @@ pub fn mock_dependencies_with_custom_querier(
     contract_balance: &[Coin],
 ) -> Backend<MockApi, MockStorage, MockQuerier<SpecialQuery>> {
     let custom_querier: MockQuerier<SpecialQuery> =
-        MockQuerier::new(&[(MOCK_CONTRACT_ADDR, contract_balance)])
+        MockQuerier::new(&[(MOCK_CONTRACT_ADDR.as_str(), contract_balance)])
             .with_custom_handler(|query| SystemResult::Ok(custom_query_execute(query)));
 
     Backend {

contracts/staking/src/contract.rs

@@ -462,7 +462,7 @@ mod tests {
         let can_redelegate = amount.clone();
         FullDelegation {
             validator: Addr::unchecked(validator_addr),
-            delegator: Addr::unchecked(MOCK_CONTRACT_ADDR),
+            delegator: MOCK_CONTRACT_ADDR,
             amount,
             can_redelegate,
             accumulated_rewards: Vec::new(),

packages/std/src/addresses.rs

@@ -1,9 +1,10 @@
 #![allow(deprecated)]
 
 use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
+use serde::{de, ser, Deserialize, Deserializer, Serialize};
 use std::fmt;
 use std::ops::Deref;
+use std::str;
 
 use crate::binary::Binary;
 
@@ -23,8 +24,18 @@ use crate::binary::Binary;
 /// This type is immutable. If you really need to mutate it (Really? Are you sure?), create
 /// a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String`
 /// instance.
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, Hash, JsonSchema)]
-pub struct Addr(String);
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, JsonSchema)]
+pub struct Addr(#[schemars(with = "String")] AddrInner);
+
+/// The maximum allowed size for bech32 (https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki#bech32)
+const ADDR_MAX_LENGTH: usize = 90;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+struct AddrInner {
+    /// UTF-8 encoded human readable string
+    data: [u8; ADDR_MAX_LENGTH],
+    length: usize,
+}
 
 impl Addr {
     /// Creates a new `Addr` instance from the given input without checking the validity
@@ -42,49 +53,111 @@ impl Addr {
     /// let address = Addr::unchecked("foobar");
     /// assert_eq!(address, "foobar");
     /// ```
-    pub fn unchecked<T: Into<String>>(input: T) -> Addr {
-        Addr(input.into())
+    pub const fn unchecked(input: &str) -> Addr {
+        let input_bytes = input.as_bytes();
+        let mut data = [0u8; ADDR_MAX_LENGTH];
+        let mut i = 0;
+        while i < input_bytes.len() {
+            data[i] = input_bytes[i];
+            i += 1;
+        }
+
+        Addr(AddrInner {
+            data,
+            length: input_bytes.len(),
+        })
+    }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.0.data[..self.0.length]
+    }
+
+    pub fn as_str(&self) -> &str {
+        unsafe { str::from_utf8_unchecked(self.as_bytes()) }
     }
 }
 
 impl fmt::Display for Addr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", &self.0)
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl Serialize for Addr {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: ser::Serializer,
+    {
+        serializer.serialize_str(&self.as_str())
+    }
+}
+
+impl<'de> Deserialize<'de> for Addr {
+    fn deserialize<D>(deserializer: D) -> Result<Addr, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(AddrVisitor)
+    }
+}
+
+struct AddrVisitor;
+
+impl<'de> de::Visitor<'de> for AddrVisitor {
+    type Value = Addr;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("Human readable address string")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if v.len() > ADDR_MAX_LENGTH {
+            Err(E::custom(format!(
+                "Input too long to be stored in an Addr. Max: {}, actual: {}",
+                ADDR_MAX_LENGTH,
+                v.len()
+            )))
+        } else {
+            Ok(Addr::unchecked(v))
+        }
     }
 }
 
 impl AsRef<str> for Addr {
     #[inline]
     fn as_ref(&self) -> &str {
-        &self.0
+        self.as_str()
     }
 }
 
 /// Implement `Addr == &str`
 impl PartialEq<&str> for Addr {
     fn eq(&self, rhs: &&str) -> bool {
-        self.0 == *rhs
+        self.as_str() == *rhs
     }
 }
 
 /// Implement `&str == Addr`
 impl PartialEq<Addr> for &str {
     fn eq(&self, rhs: &Addr) -> bool {
-        *self == rhs.0
+        *self == rhs.as_str()
     }
 }
 
 /// Implement `Addr == String`
 impl PartialEq<String> for Addr {
     fn eq(&self, rhs: &String) -> bool {
-        &self.0 == rhs
+        self.as_str() == rhs
     }
 }
 
 /// Implement `String == Addr`
 impl PartialEq<Addr> for String {
     fn eq(&self, rhs: &Addr) -> bool {
-        self == &rhs.0
+        self == rhs.as_str()
     }
 }
 
@@ -93,25 +166,25 @@ impl PartialEq<Addr> for String {
 
 impl From<Addr> for String {
     fn from(addr: Addr) -> Self {
-        addr.0
+        addr.as_str().to_owned()
     }
 }
 
 impl From<&Addr> for String {
     fn from(addr: &Addr) -> Self {
-        addr.0.clone()
+        addr.as_str().to_owned()
     }
 }
 
 impl From<Addr> for HumanAddr {
     fn from(addr: Addr) -> Self {
-        HumanAddr(addr.0)
+        HumanAddr(addr.into())
     }
 }
 
 impl From<&Addr> for HumanAddr {
     fn from(addr: &Addr) -> Self {
-        HumanAddr(addr.0.clone())
+        HumanAddr(addr.into())
     }
 }
 
@@ -268,7 +341,7 @@ mod tests {
     #[test]
     fn addr_unchecked_works() {
         let a = Addr::unchecked("123");
-        let aa = Addr::unchecked(String::from("123"));
+        let aa = Addr::unchecked("123");
         let b = Addr::unchecked("be");
         assert_eq!(a, aa);
         assert_ne!(a, b);

packages/std/src/imports.rs

@@ -205,7 +205,7 @@ impl Api for ExternalApi {
         }
 
         let address = unsafe { consume_string_region_written_by_vm(human) };
-        Ok(Addr::unchecked(address))
+        Ok(Addr::unchecked(&address))
     }
 
     fn secp256k1_verify(

packages/std/src/mock.rs

@@ -21,7 +21,7 @@ use crate::storage::MemoryStorage;
 use crate::traits::{Api, Querier, QuerierResult};
 use crate::types::{BlockInfo, ContractInfo, Env, MessageInfo};
 
-pub const MOCK_CONTRACT_ADDR: &str = "cosmos2contract";
+pub const MOCK_CONTRACT_ADDR: Addr = Addr::unchecked("cosmos2contract");
 
 /// All external requirements that can be injected for unit tests.
 /// It sets the given balance for the contract itself, nothing else
@@ -31,7 +31,7 @@ pub fn mock_dependencies(
     OwnedDeps {
         storage: MockStorage::default(),
         api: MockApi::default(),
-        querier: MockQuerier::new(&[(MOCK_CONTRACT_ADDR, contract_balance)]),
+        querier: MockQuerier::new(&[(MOCK_CONTRACT_ADDR.as_str(), contract_balance)]),
     }
 }
 
@@ -121,7 +121,7 @@ impl Api for MockApi {
         let trimmed = tmp.into_iter().filter(|&x| x != 0x00).collect();
         // decode UTF-8 bytes into string
         let human = String::from_utf8(trimmed)?;
-        Ok(Addr::unchecked(human))
+        Ok(Addr::unchecked(&human))
     }
 
     fn secp256k1_verify(
@@ -191,16 +191,16 @@ pub fn mock_env() -> Env {
             chain_id: "cosmos-testnet-14002".to_string(),
         },
         contract: ContractInfo {
-            address: Addr::unchecked(MOCK_CONTRACT_ADDR),
+            address: MOCK_CONTRACT_ADDR,
         },
     }
 }
 
 /// Just set sender and funds for the message.
 /// This is intended for use in test code only.
-pub fn mock_info(sender: &str, funds: &[Coin]) -> MessageInfo {
+pub fn mock_info<S: AsRef<str>>(sender: S, funds: &[Coin]) -> MessageInfo {
     MessageInfo {
-        sender: Addr::unchecked(sender),
+        sender: Addr::unchecked(sender.as_ref()),
         funds: funds.to_vec(),
     }
 }

packages/vm/src/testing/instance.rs

@@ -135,7 +135,7 @@ pub fn mock_instance_with_options(
         if let Some(pos) = balances.iter().position(|item| item.0 == contract_address) {
             balances.remove(pos);
         }
-        balances.push((contract_address, contract_balance));
+        balances.push((contract_address.as_str(), contract_balance));
     }
 
     let api = if let Some(backend_error) = options.backend_error {

packages/vm/src/testing/mock.rs

@@ -5,7 +5,7 @@ use super::querier::MockQuerier;
 use super::storage::MockStorage;
 use crate::{Backend, BackendApi, BackendError, BackendResult, GasInfo};
 
-pub const MOCK_CONTRACT_ADDR: &str = "cosmos2contract";
+pub const MOCK_CONTRACT_ADDR: Addr = Addr::unchecked("cosmos2contract");
 const GAS_COST_HUMANIZE: u64 = 44;
 const GAS_COST_CANONICALIZE: u64 = 55;
 
@@ -15,7 +15,7 @@ pub fn mock_backend(contract_balance: &[Coin]) -> Backend<MockApi, MockStorage,
     Backend {
         api: MockApi::default(),
         storage: MockStorage::default(),
-        querier: MockQuerier::new(&[(MOCK_CONTRACT_ADDR, contract_balance)]),
+        querier: MockQuerier::new(&[(MOCK_CONTRACT_ADDR.as_str(), contract_balance)]),
     }
 }
 
@@ -149,16 +149,16 @@ pub fn mock_env() -> Env {
             chain_id: "cosmos-testnet-14002".to_string(),
         },
         contract: ContractInfo {
-            address: Addr::unchecked(MOCK_CONTRACT_ADDR),
+            address: MOCK_CONTRACT_ADDR,
         },
     }
 }
 
 /// Just set sender and funds for the message.
 /// This is intended for use in test code only.
-pub fn mock_info(sender: &str, funds: &[Coin]) -> MessageInfo {
+pub fn mock_info<S: AsRef<str>>(sender: S, funds: &[Coin]) -> MessageInfo {
     MessageInfo {
-        sender: Addr::unchecked(sender),
+        sender: Addr::unchecked(sender.as_ref()),
         funds: funds.to_vec(),
     }
 }