Replace vm MockApi with bech32

Author: chipshort

Cargo.lock

@@ -5,7 +5,6 @@
 
 mod assertions;
 mod mock;
-mod shuffle;
 
 pub use assertions::assert_approx_eq_impl;
 #[cfg(test)]
@@ -26,4 +25,3 @@ pub use mock::{
     mock_ibc_channel_connect_ack, mock_ibc_channel_connect_confirm, mock_ibc_channel_open_init,
     mock_ibc_channel_open_try, mock_ibc_packet_ack, mock_ibc_packet_recv, mock_ibc_packet_timeout,
 };
-pub use shuffle::riffle_shuffle;

packages/std/src/testing/mod.rs

@@ -29,6 +29,7 @@ bench = false
 bytes = "1.4.0"     # need a higher version than the one required by Wasmer for the Bytes -> Vec<u8> implementation
 clru = "0.6.1"
 crc32fast = "1.3.2"
+bech32 = "0.9.1"
 # Uses the path when built locally; uses the given version from crates.io when published
 cosmwasm-std = { path = "../std", version = "1.5.0", default-features = false }
 cosmwasm-crypto = { path = "../crypto", version = "1.5.0" }

packages/std/src/testing/shuffle.rs

@@ -197,6 +197,19 @@ pub trait Querier {
 /// must always have gas information attached.
 pub type BackendResult<T> = (core::result::Result<T, BackendError>, GasInfo);
 
+/// The equivalent of the `?` operator, but for a [`BackendResult`]
+macro_rules! try_br {
+    ($res: expr $(,)?) => {
+        let (result, gas) = $res;
+
+        match result {
+            Ok(v) => v,
+            Err(e) => return (Err(e), gas),
+        }
+    };
+}
+pub(crate) use try_br;
+
 #[derive(Error, Debug, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum BackendError {

packages/vm/Cargo.toml

@@ -1140,23 +1140,23 @@ mod tests {
         }
     }
 
+    const CANONICAL_ADDRESS_BUFFER_LENGTH: u32 = 64;
+
     #[test]
     fn do_addr_canonicalize_works() {
         let api = MockApi::default();
         let (fe, mut store, instance) = make_instance(api);
         let mut fe_mut = fe.into_mut(&mut store);
-        let api = MockApi::default();
 
         let source_ptr = write_data(&mut fe_mut, b"foo");
-        let dest_ptr = create_empty(&instance, &mut fe_mut, api.canonical_length() as u32);
+        let dest_ptr = create_empty(&instance, &mut fe_mut, CANONICAL_ADDRESS_BUFFER_LENGTH);
 
         leave_default_data(&mut fe_mut);
 
-        let api = MockApi::default();
         let res = do_addr_canonicalize(fe_mut.as_mut(), source_ptr, dest_ptr).unwrap();
         assert_eq!(res, 0);
         let data = force_read(&mut fe_mut, dest_ptr);
-        assert_eq!(data.len(), api.canonical_length());
+        assert_eq!(data.len(), CANONICAL_ADDRESS_BUFFER_LENGTH as usize);
     }
 
     #[test]
@@ -1257,7 +1257,7 @@ mod tests {
                 ..
             } => {
                 assert_eq!(size, 7);
-                assert_eq!(required, api.canonical_length());
+                assert_eq!(required, CANONICAL_ADDRESS_BUFFER_LENGTH as usize);
             }
             err => panic!("Incorrect error returned: {err:?}"),
         }
@@ -1268,9 +1268,8 @@ mod tests {
         let api = MockApi::default();
         let (fe, mut store, instance) = make_instance(api);
         let mut fe_mut = fe.into_mut(&mut store);
-        let api = MockApi::default();
 
-        let source_data = vec![0x22; api.canonical_length()];
+        let source_data = vec![0x22; CANONICAL_ADDRESS_BUFFER_LENGTH as usize];
         let source_ptr = write_data(&mut fe_mut, &source_data);
         let dest_ptr = create_empty(&instance, &mut fe_mut, 70);
 
@@ -1351,9 +1350,8 @@ mod tests {
         let api = MockApi::default();
         let (fe, mut store, instance) = make_instance(api);
         let mut fe_mut = fe.into_mut(&mut store);
-        let api = MockApi::default();
 
-        let source_data = vec![0x22; api.canonical_length()];
+        let source_data = vec![0x22; CANONICAL_ADDRESS_BUFFER_LENGTH as usize];
         let source_ptr = write_data(&mut fe_mut, &source_data);
         let dest_ptr = create_empty(&instance, &mut fe_mut, 2);
 
@@ -1366,7 +1364,7 @@ mod tests {
                 ..
             } => {
                 assert_eq!(size, 2);
-                assert_eq!(required, api.canonical_length());
+                assert_eq!(required, CANONICAL_ADDRESS_BUFFER_LENGTH as usize);
             }
             err => panic!("Incorrect error returned: {err:?}"),
         }

packages/vm/src/backend.rs

@@ -1,16 +1,20 @@
-use cosmwasm_std::testing::{digit_sum, riffle_shuffle};
+use bech32::{decode, encode, FromBase32, ToBase32, Variant};
 use cosmwasm_std::{
     Addr, BlockInfo, Coin, ContractInfo, Env, MessageInfo, Timestamp, TransactionInfo,
 };
 
 use super::querier::MockQuerier;
 use super::storage::MockStorage;
+use crate::backend::try_br;
 use crate::{Backend, BackendApi, BackendError, BackendResult, GasInfo};
 
-pub const MOCK_CONTRACT_ADDR: &str = "cosmos2contract";
+pub const MOCK_CONTRACT_ADDR: &str = "cosmwasmcontract"; // TODO: use correct address
 const GAS_COST_HUMANIZE: u64 = 44; // TODO: these seem very low
 const GAS_COST_CANONICALIZE: u64 = 55;
 
+/// Default prefix used when creating Bech32 encoded address.
+const BECH32_PREFIX: &str = "cosmwasm";
+
 /// All external requirements that can be injected for unit tests.
 /// It sets the given balance for the contract itself, nothing else
 pub fn mock_backend(contract_balance: &[Coin]) -> Backend<MockApi, MockStorage, MockQuerier> {
@@ -33,130 +37,82 @@ pub fn mock_backend_with_balances(
     }
 }
 
-/// Length of canonical addresses created with this API. Contracts should not make any assumptions
-/// what this value is.
-///
-/// The value here must be restorable with `SHUFFLES_ENCODE` + `SHUFFLES_DECODE` in-shuffles.
-/// See <https://oeis.org/A002326/list> for a table of those values.
-const CANONICAL_LENGTH: usize = 64; // n = 32
-
-const SHUFFLES_ENCODE: usize = 10;
-const SHUFFLES_DECODE: usize = 2;
-
 /// Zero-pads all human addresses to make them fit the canonical_length and
 /// trims off zeros for the reverse operation.
 /// This is not really smart, but allows us to see a difference (and consistent length for canonical adddresses).
 #[derive(Copy, Clone)]
-pub struct MockApi {
-    /// Length of canonical addresses created with this API. Contracts should not make any assumptions
-    /// what this value is.
-    canonical_length: usize,
-    /// When set, all calls to the API fail with BackendError::Unknown containing this message
-    backend_error: Option<&'static str>,
+pub enum MockApi {
+    /// With this variant, all calls to the API fail with BackendError::Unknown
+    /// containing the given message
+    Error(&'static str),
+    /// This variant implements Bech32 addresses.
+    Bech32 {
+        /// Prefix used for creating addresses in Bech32 encoding.
+        bech32_prefix: &'static str,
+    },
 }
 
 impl MockApi {
-    /// Read-only getter for `canonical_length`, which must not be changed by the caller.
-    pub fn canonical_length(&self) -> usize {
-        self.canonical_length
-    }
-
     pub fn new_failing(backend_error: &'static str) -> Self {
-        MockApi {
-            backend_error: Some(backend_error),
-            ..MockApi::default()
-        }
+        MockApi::Error(backend_error)
     }
 }
 
 impl Default for MockApi {
     fn default() -> Self {
-        MockApi {
-            canonical_length: CANONICAL_LENGTH,
-            backend_error: None,
+        MockApi::Bech32 {
+            bech32_prefix: BECH32_PREFIX,
         }
     }
 }
 
 impl BackendApi for MockApi {
     fn canonical_address(&self, input: &str) -> BackendResult<Vec<u8>> {
-        // mimicks formats like hex or bech32 where different casings are valid for one address
-        let normalized = input.to_lowercase();
-
         let gas_info = GasInfo::with_cost(GAS_COST_CANONICALIZE);
 
-        if let Some(backend_error) = self.backend_error {
-            return (Err(BackendError::unknown(backend_error)), gas_info);
-        }
-
-        // Dummy input validation. This is more sophisticated for formats like bech32, where format and checksum are validated.
-        let min_length = 3;
-        let max_length = self.canonical_length;
-        if normalized.len() < min_length {
-            return (
-                Err(BackendError::user_err(
-                    format!("Invalid input: human address too short for this mock implementation (must be >= {min_length})."),
-                )),
-                gas_info,
-            );
-        }
-        if normalized.len() > max_length {
-            return (
-                Err(BackendError::user_err(
-                    format!("Invalid input: human address too long for this mock implementation (must be <= {max_length})."),
-                )),
-                gas_info,
-            );
-        }
+        // handle error case
+        let bech32_prefix = match self {
+            MockApi::Error(e) => return (Err(BackendError::unknown(*e)), gas_info),
+            MockApi::Bech32 { bech32_prefix } => *bech32_prefix,
+        };
 
-        let mut out = Vec::from(normalized);
-        // pad to canonical length with NULL bytes
-        out.resize(self.canonical_length, 0x00);
-        // content-dependent rotate followed by shuffle to destroy
-        // the most obvious structure (https://github.com/CosmWasm/cosmwasm/issues/552)
-        let rotate_by = digit_sum(&out) % self.canonical_length;
-        out.rotate_left(rotate_by);
-        for _ in 0..SHUFFLES_ENCODE {
-            out = riffle_shuffle(&out);
+        if let Ok((prefix, decoded, Variant::Bech32)) = decode(input) {
+            if prefix == bech32_prefix {
+                if let Ok(bytes) = Vec::<u8>::from_base32(&decoded) {
+                    try_br!((validate_length(&bytes), gas_info));
+                    return (Ok(bytes), gas_info);
+                }
+            }
         }
-        (Ok(out), gas_info)
+        (Err(BackendError::user_err("Invalid input")), gas_info)
     }
 
     fn human_address(&self, canonical: &[u8]) -> BackendResult<String> {
         let gas_info = GasInfo::with_cost(GAS_COST_HUMANIZE);
 
-        if let Some(backend_error) = self.backend_error {
-            return (Err(BackendError::unknown(backend_error)), gas_info);
-        }
+        // handle error case
+        let bech32_prefix = match self {
+            MockApi::Error(e) => return (Err(BackendError::unknown(*e)), gas_info),
+            MockApi::Bech32 { bech32_prefix } => *bech32_prefix,
+        };
 
-        if canonical.len() != self.canonical_length {
-            return (
-                Err(BackendError::user_err(
-                    "Invalid input: canonical address length not correct",
-                )),
-                gas_info,
-            );
-        }
+        try_br!((validate_length(canonical.as_ref()), gas_info));
 
-        let mut tmp: Vec<u8> = canonical.into();
-        // Shuffle two more times which restored the original value (24 elements are back to original after 20 rounds)
-        for _ in 0..SHUFFLES_DECODE {
-            tmp = riffle_shuffle(&tmp);
-        }
-        // Rotate back
-        let rotate_by = digit_sum(&tmp) % self.canonical_length;
-        tmp.rotate_right(rotate_by);
-        // Remove NULL bytes (i.e. the padding)
-        let trimmed = tmp.into_iter().filter(|&x| x != 0x00).collect();
+        let result = encode(bech32_prefix, canonical.to_base32(), Variant::Bech32)
+            .map_err(|_| BackendError::user_err("Invalid canonical address"));
 
-        let result = match String::from_utf8(trimmed) {
-            Ok(human) => Ok(human),
-            Err(err) => Err(err.into()),
-        };
         (result, gas_info)
     }
 }
 
+/// Does basic validation of the number of bytes in a canonical address
+fn validate_length(bytes: &[u8]) -> Result<(), BackendError> {
+    if !(1..=255).contains(&bytes.len()) {
+        return Err(BackendError::user_err("Invalid canonical address length"));
+    }
+    Ok(())
+}
+
 /// Returns a default enviroment with height, time, chain_id, and contract address
 /// You can submit as is to most contracts, or modify height/time if you want to
 /// test for expiration.