Merge pull request #1914 from CosmWasm/1873-new-impl-canonicalize-humanize

[2.0] New implementation of addr_canonicalize and addr_humanize functions

Author: webmaster128

CHANGELOG.md

@@ -64,6 +64,8 @@ and this project adheres to
 - cosmwasm-vm: Removed `backtraces` feature, use the `RUST_BACKTRACE=1` env
   variable instead. All `VmError` variants now have a `backtrace` field.
   ([#1967])
+- cosmwasm-std: Replace `MockApi` with bech32 implementation. ([#1914])
+- cosmwasm-vm: Replace `MockApi` with bech32 implementation. ([#1914])
 
 [#1874]: https://github.com/CosmWasm/cosmwasm/pull/1874
 [#1876]: https://github.com/CosmWasm/cosmwasm/pull/1876
@@ -72,6 +74,7 @@ and this project adheres to
 [#1884]: https://github.com/CosmWasm/cosmwasm/pull/1884
 [#1898]: https://github.com/CosmWasm/cosmwasm/pull/1898
 [#1902]: https://github.com/CosmWasm/cosmwasm/pull/1902
+[#1914]: https://github.com/CosmWasm/cosmwasm/pull/1914
 [#1926]: https://github.com/CosmWasm/cosmwasm/pull/1926
 [#1933]: https://github.com/CosmWasm/cosmwasm/pull/1933
 [#1939]: https://github.com/CosmWasm/cosmwasm/pull/1939

Cargo.lock

@@ -135,6 +135,39 @@ major releases of `cosmwasm`. Note that you can also view the
   +StdError::generic_err(msg)
   ```
 
+- Replace addresses in unit tests with valid bech32 addresses. This has to be
+  done for all addresses that are validated or canonicalized during the test or
+  within the contract. The easiest way to do this is by using
+  `MockApi::addr_make`. It generates a bech32 address from any string:
+
+  ```diff
+  -let msg = InstantiateMsg {
+  -    verifier: "verifier".to_string(),
+  -    beneficiary: "beneficiary".to_string(),
+  -};
+  +let msg = InstantiateMsg {
+  +    verifier: deps.api.addr_make("verifier").to_string(),
+  +    beneficiary: deps.api.addr_make("beneficiary").to_string(),
+  +};
+  ```
+
+- Replace addresses in integration tests using `cosmwasm-vm` with valid bech32
+  addresses. This has to be done for all addresses that are validated or
+  canonicalized during the test or within the contract. The easiest way to do
+  this is by using `MockApi::addr_make`. It generates a bech32 address from any
+  string:
+
+  ```diff
+  -let msg = InstantiateMsg {
+  -    verifier: "verifier".to_string(),
+  -    beneficiary: "beneficiary".to_string(),
+  -};
+  +let msg = InstantiateMsg {
+  +    verifier: instance.api().addr_make("verifier").to_string(),
+  +    beneficiary: instance.api().addr_make("beneficiary").to_string(),
+  +};
+  ```
+
 ## 1.4.x -> 1.5.0
 
 - Update `cosmwasm-*` dependencies in Cargo.toml (skip the ones you don't use):

MIGRATING.md

@@ -195,22 +195,8 @@ fn do_user_errors_in_api_calls(api: &dyn Api) -> Result<Response, HackError> {
         }
     }
 
-    let too_long =
-        "bn9hhssomeltvhzgvuqkwjkpwxojfuigltwedayzxljucefikuieillowaticksoistqoynmgcnj219aewfwefwwegwg";
-    match api.addr_canonicalize(too_long).unwrap_err() {
-        StdError::GenericErr { .. } => {}
-        err => {
-            return Err(StdError::generic_err(format!(
-                "Unexpected error in do_user_errors_in_api_calls: {err:?}"
-            ))
-            .into())
-        }
-    }
-
-    // Humanize
-
-    let empty: CanonicalAddr = vec![].into();
-    match api.addr_humanize(&empty).unwrap_err() {
+    let invalid = "bn9hhssomeltvhzgvuqkwjkpwxoj";
+    match api.addr_canonicalize(invalid).unwrap_err() {
         StdError::GenericErr { .. } => {}
         err => {
             return Err(StdError::generic_err(format!(
@@ -220,8 +206,8 @@ fn do_user_errors_in_api_calls(api: &dyn Api) -> Result<Response, HackError> {
         }
     }
 
-    let too_short: CanonicalAddr = vec![0xAA, 0xBB, 0xCC].into();
-    match api.addr_humanize(&too_short).unwrap_err() {
+    let too_long = "cosmwasm1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqehqqkz";
+    match api.addr_canonicalize(too_long).unwrap_err() {
         StdError::GenericErr { .. } => {}
         err => {
             return Err(StdError::generic_err(format!(
@@ -231,8 +217,9 @@ fn do_user_errors_in_api_calls(api: &dyn Api) -> Result<Response, HackError> {
         }
     }
 
-    let wrong_length: CanonicalAddr = vec![0xA6; 17].into();
-    match api.addr_humanize(&wrong_length).unwrap_err() {
+    // Humanize
+    let empty: CanonicalAddr = vec![].into();
+    match api.addr_humanize(&empty).unwrap_err() {
         StdError::GenericErr { .. } => {}
         err => {
             return Err(StdError::generic_err(format!(
@@ -316,9 +303,9 @@ mod tests {
     fn proper_initialization() {
         let mut deps = mock_dependencies();
 
-        let verifier = String::from("verifies");
-        let beneficiary = String::from("benefits");
-        let creator = String::from("creator");
+        let verifier: String = deps.api.addr_make("verifies").into();
+        let beneficiary: String = deps.api.addr_make("benefits").into();
+        let creator: String = deps.api.addr_make("creator").into();
         let expected_state = State {
             verifier: deps.api.addr_validate(&verifier).unwrap(),
             beneficiary: deps.api.addr_validate(&beneficiary).unwrap(),
@@ -344,9 +331,9 @@ mod tests {
     fn instantiate_and_query() {
         let mut deps = mock_dependencies();
 
-        let verifier = String::from("verifies");
-        let beneficiary = String::from("benefits");
-        let creator = String::from("creator");
+        let verifier: String = deps.api.addr_make("verifies").into();
+        let beneficiary: String = deps.api.addr_make("benefits").into();
+        let creator: String = deps.api.addr_make("creator").into();
         let msg = InstantiateMsg {
             verifier: verifier.clone(),
             beneficiary,
@@ -364,11 +351,11 @@ mod tests {
     fn migrate_verifier() {
         let mut deps = mock_dependencies();
 
-        let verifier = String::from("verifies");
-        let beneficiary = String::from("benefits");
-        let creator = String::from("creator");
+        let verifier: String = deps.api.addr_make("verifies").into();
+        let beneficiary: String = deps.api.addr_make("benefits").into();
+        let creator: String = deps.api.addr_make("creator").into();
         let msg = InstantiateMsg {
-            verifier,
+            verifier: verifier.clone(),
             beneficiary,
         };
         let info = mock_info(&creator, &[]);
@@ -377,10 +364,13 @@ mod tests {
 
         // check it is 'verifies'
         let query_response = query(deps.as_ref(), mock_env(), QueryMsg::Verifier {}).unwrap();
-        assert_eq!(query_response.as_slice(), b"{\"verifier\":\"verifies\"}");
+        assert_eq!(
+            query_response.as_slice(),
+            format!(r#"{{"verifier":"{verifier}"}}"#).as_bytes()
+        );
 
         // change the verifier via migrate
-        let new_verifier = String::from("someone else");
+        let new_verifier: String = deps.api.addr_make("someone else").into();
         let msg = MigrateMsg {
             verifier: new_verifier.clone(),
         };
@@ -396,9 +386,9 @@ mod tests {
     fn sudo_can_steal_tokens() {
         let mut deps = mock_dependencies();
 
-        let verifier = String::from("verifies");
-        let beneficiary = String::from("benefits");
-        let creator = String::from("creator");
+        let verifier: String = deps.api.addr_make("verifies").into();
+        let beneficiary: String = deps.api.addr_make("benefits").into();
+        let creator: String = deps.api.addr_make("creator").into();
         let msg = InstantiateMsg {
             verifier,
             beneficiary,
@@ -440,9 +430,9 @@ mod tests {
         let mut deps = mock_dependencies();
 
         // initialize the store
-        let creator = String::from("creator");
-        let verifier = String::from("verifies");
-        let beneficiary = String::from("benefits");
+        let creator: String = deps.api.addr_make("creator").into();
+        let verifier: String = deps.api.addr_make("verifies").into();
+        let beneficiary: String = deps.api.addr_make("benefits").into();
 
         let instantiate_msg = InstantiateMsg {
             verifier: verifier.clone(),
@@ -470,13 +460,13 @@ mod tests {
         assert_eq!(
             msg,
             &SubMsg::new(BankMsg::Send {
-                to_address: beneficiary,
+                to_address: beneficiary.clone(),
                 amount: coins(1000, "earth"),
             }),
         );
         assert_eq!(
             execute_res.attributes,
-            vec![("action", "release"), ("destination", "benefits")],
+            vec![("action", "release"), ("destination", &beneficiary)],
         );
         assert_eq!(execute_res.data, Some(vec![0xF0, 0x0B, 0xAA].into()));
     }
@@ -486,9 +476,9 @@ mod tests {
         let mut deps = mock_dependencies();
 
         // initialize the store
-        let creator = String::from("creator");
-        let verifier = String::from("verifies");
-        let beneficiary = String::from("benefits");
+        let creator: String = deps.api.addr_make("creator").into();
+        let verifier: String = deps.api.addr_make("verifies").into();
+        let beneficiary: String = deps.api.addr_make("benefits").into();
 
         let instantiate_msg = InstantiateMsg {
             verifier: verifier.clone(),
@@ -531,9 +521,9 @@ mod tests {
         let mut deps = mock_dependencies();
 
         // initialize the store
-        let verifier = String::from("verifies");
-        let beneficiary = String::from("benefits");
-        let creator = String::from("creator");
+        let verifier: String = deps.api.addr_make("verifies").into();
+        let beneficiary: String = deps.api.addr_make("benefits").into();
+        let creator: String = deps.api.addr_make("creator").into();
 
         let instantiate_msg = InstantiateMsg {
             verifier,
@@ -558,8 +548,8 @@ mod tests {
         let mut deps = mock_dependencies();
 
         let instantiate_msg = InstantiateMsg {
-            verifier: String::from("verifies"),
-            beneficiary: String::from("benefits"),
+            verifier: deps.api.addr_make("verifies").into(),
+            beneficiary: deps.api.addr_make("benefits").into(),
         };
         let init_info = mock_info("creator", &coins(1000, "earth"));
         let init_res = instantiate(deps.as_mut(), mock_env(), init_info, instantiate_msg).unwrap();
@@ -584,7 +574,7 @@ mod tests {
         let contract = Addr::unchecked("my-contract");
         let bin_contract: &[u8] = b"my-contract";
 
-        // return the unhashed value here
+        // return the un-hashed value here
         let no_work_query = query_recurse(deps.as_ref(), 0, 0, contract.clone()).unwrap();
         assert_eq!(no_work_query.hashed, Binary::from(bin_contract));